Ask HN: What is a modern Java environment?

[smorgusofborg]

Hello,

I used Java a very long time ago, like 1.6, and I'm wondering what using Java at work in ~web backend looks like today.

What elements of your stack would you consider most important? Do most projects lean heavily on Spring Boot or something else? Which IDE? Pointers to refreshers or concise introductions you might give a new hire would be handy too.

[exabrial]

I'll chime in my opinion: Java is getting something right that I don't see much elsewhere: Dependency Injection. Combine this with a mocking framework and you can write _actual_ isolated unit tests for every single part of your stack.

We're fans of CDI, it's a more polished Spring framework without the legacy weight. We're developing in Quarkus, MicroProfile, and bigger monoliths in Apache TomEE. We use ActiveMQ extensively for scaling. ( And I mean extensively... on a modest 512m server, we can push several thousand messages/s reliably to a _lot_ of topics and queues, all with delivered-exactly-once guarantees)

We avoid the fanfare of Docker, as really it's not needed for Java apps; they're somewhat self-contained anyway and it created more problems than it solved. For true isolation, we use systemd to create cgroups and chroots and prevent application escapes. For deployment, apps are one-jar'd down to a single executable, then packaged up in a .deb using the jdeb maven plugin. We stick with the unix philosohpy of using /etc/default for env variables that help the app locate their database or LDAP cluster.

[gavinray]

I've been a developer over a decade, never touched the JVM because I always figured it was bloated Enterprise garbage.

I did a project using GraalVM's polyglot abilities and needed an API.

Tried Spring, Micronaut, Helidon, Ktor and Quarkus.

Quarkus is the best web framework I've ever used, in any language. Can't go back now.

It's so well-architected that I was able to contribute an extension for Scala 3 support within a month, and the Redhat employees have answered every question + issue I've raised.

Being built on top of the Microfile spec and using Vert.x is a hell of a combo. Vert.x is the best thing since sliced bread too.

Can't recommend Quarkus enough, whether you write Java or Kotlin or Scala (I'm a big Kotlin fan myself).

[ActorNightly]

While you are correct that DI is very good in java, DI is needed because of heavy reliance on OOP (i.e, in order to create an instance of an object, you have to lock in functionality with a dependency before you can run that functionality).

If you use a language that doesn't require OOP, you can do the same isolated unit tests without DI.

[metaltyphoon]

> Java is getting something right that I don't see much elsewhere: Dependency Injection. Combine this with a mocking framework and you can write _actual_ isolated unit tests for every single part of your stack

Since dotnet core started this has been front and center in C#. So there are other stacks doing this.

[thedougd]

I prefer to skip the mocking frameworks and rely on Interfaces instead. My unit tests create anonymous inner classes that are passed to the constructors.

If it takes too much effort to write that anonymous inner class, then the Interface may be too big and need broken up. Or maybe you're hiding too much state and need to rethink the API.

[edmcnulty101]

Containerization is great. It allows you to write all the infrastructure for you Java app as code and then just simply type 'docker-compose up' to get it running (or whatever your orchestrator).

This makes it super portable.

Just something to think about.

I personally think the win's from Containerization are greater than the challenges.

[lloydatkinson]

"something right that I don't see much elsewhere: Dependency Injection. Combine this with a mocking framework and you can write _actual_ isolated unit tests for every single part of your stack."

It's exactly the same in the .NET space

[omgitsabird]

> We avoid the fanfare of Docker, as really it's not needed for Java apps; they're somewhat self-contained anyway and it created more problems than it solved.

What does this mean?

[matsemann]

The stack I've seen, used and liked at many clients is: Spring Boot, Kotlin, IntelliJ.

Which of course means all the old discussions: Jetty/Tomcat/JBoss/GlassFish, GSON/Jackson, Hikari/C3PO/etc, etc are now mostly moot, since most just use the Boot defaults until they need something else. Kinda nice, actually. Less bikeshedding, can get a project up and running without taking a stand on all these things.

Most clients use maven, a few gradle, some used gradle and moved back when no one could understand their config. Gradle might get a second chance now that it can be written using kotlin.

[jillesvangurp]

Yes. Perhaps to add to this, use a modern asynchronous IO framework. If you use Spring Boot, ignore some of the legacy stuff that still comes with it and make sure you use webflux with Kotlin co-routines. Also use Asynchronous IO for talking to your database, queues, etc. Kotlin makes all of this easy. Hibernate is something I tend to avoid for various reasons but apparently recent versions of that now also support asynchronous IO. And it is still very popular.

If you feel more adventurous. Ktor is also quite nice and a lot more lightweight than spring. They have a pretty big 2.0 release coming up for that with a lot of nice improvements. Ktor is also a nice alternative for doing http clients. Kotlinx serialization is the way to for serialization; especially if you are interested in multiplatform. Spring supports that as well since a few releases.

If you use Kotlin, stick with Gradle and use the kotlin scripting variety. Maven is very much a second class citizen in that ecosystem. It's supported (grudgingly) but not that actually that widely used. A lot of older Spring projects might still use it because they started out as maven/java projects and only later added Kotlin. However, if you start from scratch, just use gradle and take the path of the least amount of resistance. You'll have an easier time and essentially all of the Kotlin documentation assumes you use gradle. For things like kotlin multi-platform, maven is an afterthought. I'd be surprised it works at all actually for that.

[luciusdomitius]

This is it. The irony is that the modern Java stack uses the JVM & classlib, but a different language.

If you want to go full hipster, there is Micronaut (also Quarkus) and if you'd like to go a bit off-charts, there is Dropwizard. I don't think that they offer anything extra over SB though.

[joshenberg]

Can confirm this is my stack at a fortune 500 web/entertainment company.

[sylens]

As someone who hasn't really touched the Java ecosystem since around the time of Java 7, where would you recommend starting?

Pick up Kotlin first, then Spring Boot? Or the reverse? And is the free version of IntelliJ good enough? I noticed on the features list that Spring support wasn't listed

[davidjfelix]

* Use SDKMan for runtime and sdk management https://sdkman.io/

* Try to use Kotlin where allowed (Maybe unpopular and bad faith response given that you asked about Java, but I don't care -- kotlin's Java interop is way more seamless than Scala or Clojure to the point that its often not even noticable) https://kotlinlang.org/

* IntelliJ

* Spring is pretty popular, I've seen a lot of people using Vertx

* Square libraries like Okio, okhttp, retrofit, wire https://github.com/square

* If you're not using spring, use Dagger for DI https://dagger.dev/dev-guide/

* Overlook netflix abandonware (another unpopular opinion, I'm sure)

* Use gradle, not maven. Use kotlinscript as the config language, not groovy

[jillesvangurp]

I'd suggest using koin instead of Dagger. Dagger is alright but mainly popular in the Android world where Koin is the main alternative. However, Koin is native to Kotlin and a kotlin multiplatform project. So you can use it on Android, server development, IOS native, kotlin-js, etc.

[sk5t]

Okio is very nice, and Okhttp is quite ergonoic, but I can't recommend Okhttp if true async is on the table (it's just blocking and threadpools under the covers).

[oauea]

> Try to use Kotlin where allowed

If you want a slow build and code that is fun to write but hell to read, that is good advice.

> Use kotlinscript as the config language

Extremely slow, that is.

[ojhughes]

Along with the various other libraries and frameworks mentioned;

* Testcontainers - seamless support for using Docker in integration tests [1]

* Project Reactor - nice framework for reactive programming [2]

* Executable Jars - No need to deploy a War file to a servlet container anymore. Build an executable Jar with an embedded container. Spring Boot makes this very easy

1. https://www.testcontainers.org

2. https://projectreactor.io

[mooreds]

My company's product is primarily written in Java. It's a web based auth system, fwiw.

I don't write too much code nowadays, but read a lot. From what I can see, here's the stack:

* intellij for an ide (with tons of plugins)

* prime MVC (https://github.com/prime-framework/prime-mvc) for the framework

* mybatis for SQL/queries

* java 17

I've also used dropwizard and spring. If it was a greenfield development with emphasis on developer productivity, I'd go with spring any day. Big dev community, tons of doco, a solution for any problem if you can find it.

[kitd]

For backend frameworks, I'd look at Quarkus [1] or Micronaut [2]. Both are geared towards configuration, async processing and native compilation, along with a ton of options to integrate with external systems.

For something a bit lighter weight, Vert.x [3] is a good option (Quarkus is based on it).

[1] - https://quarkus.io/

[2] - https://micronaut.io/

[3] - https://vertx.io/

You'll need Java 1.8+, and Maven or Gradle for the toolchain (I prefer the former). Intellij is the best IDE but I get by with VSCode.

[isbvhodnvemrwvn]

There's no reason to use 10 years old version of Java. Use 17.

[splix]

Here is what we use and I'd recommend to others.

The most common: - Kotlin for most of the backend code, but Java for shared libs. We still use Java 8 for some libs which may be used in Android, that's an unfortunate reality

- Gradle for build config

- Spring for application architecture

And few things that may significantly improve your dev process, but are not so common:

- Spring Reactor (and Webflux) for processing data and requests. Takes a time to learn, but it worth it

- Thymeleaf for UI

- Spock for testing. Highly recommended for designing tests

- Testcontainers for integration tests

- Micrometer to see what's going on with your app. I.e., to export all internal metrics to use with Prometheus/Grafana/etc

For the environment

- SDKMan to manager the environment

- Gradle Application plugin or Google's Jib to pacakge your app. First prepares a Zip with all binaries, second a Docker container

- IntelliJ IDEA

- Github Actions - turns out to be the most usable CI. Though the Jetbrains TeamCity may be better for a large team

[farmerbb]

> Kotlin for most of the backend code, but Java for shared libs. We still use Java 8 for some libs which may be used in Android, that's an unfortunate reality

Considering Kotlin is a supported, first-class language on Android, why not write your shared libs in Kotlin as well?

[gavinray]

- Language: Java 17/Kotlin

- API Layer: Quarkus (most projects https://github.com/quarkusio/quarkus), Vert.x (small projects https://vertx.io/)

- DB: Postgres, in-memory H2 for simple stuff

- Testing: JUnit 5, Testcontainers to automatically start + stop DB Docker containers with tests (https://www.testcontainers.org)

- Mocking: Mockito (https://github.com/mockito/mockito) or Mockk (Kotlin, https://mockk.io)

- Dependency Injection: CDI (built into Quarkus, for Vert.x you can initalize Weld when the app starts https://weld.cdi-spec.org)

- Build tool: Gradle with Kotlin DSL

- Other tools:

  Kover: automatic code-coverage reports from JaCoCo/IntelliJ (https://github.com/Kotlin/kotlinx-kover)

  Ktlint + Detekt: Kotlin linting/static analysis (https://ktlint.github.io, https://detekt.github.io/detekt)

  PMD, Spotbugs, Nullaway: Java linting/static analysis (https://pmd.github.io, https://spotbugs.github.io, https://github.com/uber/NullAway)

[stickfigure]

I have been thinking of writing up a series of articles on this. Without going into too much detail:

* IDEA

* Deploy on Google App Engine, Digital Ocean App Platform, Heroku, Elastic Beanstalk, etc - get out of the ops business entirely.

* Guice as the backbone, no Spring/Boot. I wrote a tiny dropwizard-like "framework" to make this easier: https://github.com/gwizard/gwizard but there's a laughable amount of code here, you could build it all from scratch with minimal effort. This is about as lightweight as "frameworks" get because Guice does the heavy lifting.

* JAX-RS (Resteasy) for the web API. IMO this is the best part of Java web development. HTTP endpoints are simple synchronous Java methods (with a few annotations) and you can test them like simple Java methods.

* Lombok. Use @Value heavily. Cuts most of the boilerplate out of Java.

* Junit5 + AssertJ. (Or Google Truth, which is almost identical to AssertJ).

* Use functional patterns. Try to make all variables and fields final. Use collection streams heavily. Consider vavr.io (I'll admit I haven't used it in anger yet, but I would in a new codebase).

* StreamEx. Adds a ton of useful stream behavior; I don't even use basic streams anymore.

* Guava. There's just a lot of useful stuff here.

* For the database, it really depends on what you're building. Most generic business apps, postgres/hibernate/guice-persist/flyway. Yeah, folks complain about hibernate a lot but it's a decent way to map to objects. Use SQL/native queries, don't bother with JPQL, criteria queries, etc.

* Hattery for making http requests (https://github.com/stickfigure/hattery). This is another one of mine. I make zillions of http requests, functional/immutable ergonomics really matter to me.

* Github actions for CI.

* Maven for the build. Yes, it's terrible, except for every other build system is worse. Gradle seems like it should be better but isn't. I'd really love some innovation here. Sigh.

[smorgusofborg]

Cool, it is a lot to start researching but you sound like you use a very similar style to things I am used to in other languages.

On guice/gwizard/maven, if I understand correctly I would be defining new guice DI for something like a message broker (and gwizard's solutions for similar modules might serve as a template) while probably just using direct dependencies in maven for something that doesn't need to be mocked in unit tests or replaceable in production?

[ta988]

Gradle (with Kotlin syntax), Spring Boot (vertx, ktor or for small or microservices), Kotlin, IntelliJ.

That would be a "modern" stack for me. If you can't use Kotlin, Java has improved a lot since 1.6 you will be pleasantly surprised.

I recommend you start an intellij (Free edition if you want to, even if I still recommend the paid one) and follow the springboot kotlin tutorial below. That will give you a good idea of what the ecosystem looks like these days.

https://spring.io/guides/tutorials/spring-boot-kotlin/

[ta988]

Oh and make sure you start with JDK17. I still see people starting projects with 8, you don't want that!

[MockObject]

I've been doing Java non-stop since before 1.6. I just started a new project, and it's

* IntelliJ

* Standard enterprise Java JEE 9.1 (JSP, JPA, EJB)

* Payara app server

* Twitter Bootstrap

* Maven

* Test driven development using TestNG + AssertJ

* Postgres + Liquibase for schema management

Code samples now come from https://www.baeldung.com/

[ytdytvhxgydvhh]

Just curious - you mention JSP. Was that mentioning that yeah, JSP happens to be part of JEE or are you actively using it? I haven’t heard of a new project using JSP for a while.

[PaulHoule]

IntelliJ idea is the best IDE. JDK8 incorporated a lot of great functional programming ideas (though the streams library is awful.). Up through JDK17 there are many improvements including a more scalable runtime.

I haven’t been paid to work with Spring since 2013, every project I’ve worked on since has used Guice, maybe Dropwizard.

JAX-RS is the dominant paradigm for web back ends these days, particularly if you are writing single page applications.

[jbellis]

I think the Streams designers did an amazing job. One of my favorite things about modern Java. Yes, it's more verbose than Python list comprehensions, but it's both higher-performance (parallelism that just works) and more productive (static typing means it almost always works as intended the first time).

[mhaberl]

>I haven’t been paid to work with Spring since 2013, every project I’ve worked on since has used Guice, maybe Dropwizard.

This is the opposite of my experience. I worked with Java a lot for the last 10 years or so. In the last 3 years literally each request I got for implementing stuff in Java also required Spring (Spring Boot) - and that was dozens of clients.

[shaman1]

Spring Boot (embedded Tomcat/Jetty/Netty)

Lombok

Gradle, Guava

JUnit 5, testcontainers, WireMock

Logback, Slf4j

Okhttp, Open Feign, RestTemplate

Micrometer

OpenApi, swagger

Liquidbase, jooq - db stuff

This is your run of the mill stack

Dropwizard, Vert.X seem to be less used nowadays, Spring has mostly won the show

Heard people using Kotlin, Quarkus, Micronaut but that's niche stuff

[AtlasBarfed]

IMO:

IntelliJ for IDE (Community edition is free). #1 reason is it supports Kotlin and Groovy very well out of the box. Eclipse is still a plugin disaster, and the language support aside from Java is pretty bad, although I haven't bothered to check in a few years since IntelliJ CE was released.

Gradle for builds. It is still copy and paste setup, but at least you can do a lot more things than rigid Maven.

Groovy + CompileStatic (personally) for the actual JVM language but admittedly I haven't tried Kotlin yet. Even with closures and other improvements, base Java can't compete with either of those.

Spring Boot for your enterprisey stuff/REST services which you are likely using it for. It's such a standard at this point.

Unit tests: Spock. Spock is awesome. And very well supported by IntelliJ for autoformat, another BIG reason to use IntelliJ.

Man, web frameworks on Java that don't just use it for an AJAX service layer? Who knows.

[soco]

Eclipse as IDE (actually STS - Spring Tools Suite edition) for both Spring Boot and JBoss Tools (yes there's enough work for JEE - WildFly or JBoss EAP). The build would be most of the time Maven (including the assembly plugin) and sometimes would create native Quarkus images for cloud tools (read serverless).

[AssertErNullNPE]

I can't speak to how prevalent it is in the industry, but something my team has started doing in our web services is building with GraalVM and deploying native images. The build time can be super long, but the benefit is incredibly fast start-up time, which really benefits horizontal scaling. We're using Quarkus (https://quarkus.io), which is largely built on Vertx which was mentioned elsewhere, but other frameworks (Micronaut (https://micronaut.io) comes to mind) make it easy and SpringBoot is also working on support. If your doing containers/kubernetes native images feel like the way to go.

[biehl]

Spring Boot is the go-to solution for Java where I work. And definitely Intellij as IDE.

[manishsharan]

And Maven. Don't forget Maven.

[mhaberl]

This is my experience.

For context I do a lot of contract work mostly in banking, ecommerce and insurance.

  - Spring Boot
  - IntelliJ
  - Gradle or Maven
  - Java 8 features (for various reasons most of my clients do not use version > 8)

[arez]

what about lombok? Edit: just curious if you think it's standard

[kyawzazaw]

I concur

[smallerfish]

Kotlin + Dropwizard. Avoid Hibernate, go with JDBI.

If I was starting a new project I'd look at Jooby, which looks pleasant and does very well on TechEmpower benchmarks.

[icedchai]

JDBI is pretty slick. We used it as a previous company. Previous experience was with Hibernate, lower level JDBC, and some other half baked proprietary ORMs.

[jbellis]

Good summary of the language-level changes here: https://piotrminkowski.com/2021/02/01/new-developer-friendly...

ETA: actually if you haven't used it since 1.6 you'd want to find an article on Java 8 as well that covers Streams.

[vollmond]

I'm about 3 years out of date on Java, but if I were spinning up a new project it would be:

* Latest JDK

* Spring Boot

* JQuery/Bootstrap

* Eclipse (with Vim keybindings plugin)

Caveats:

* If it was a personal project or only a very small team, I'd start with Kotlin

* I haven't tried IntelliJ in quite a while and would give it a shot to see if I wanted to switch off Eclipse now

[luciusdomitius]

Make sure you do give it a try and beyond the initial discomfort too. It has improved leaps & bounds.

[nigerian1981]

I’ve seen the Micronaut framework used instead of Spring Boot a lot recently for AWS Lambda

[throwaway4good]

Spring Boot wrapped in a Docker container and a frontend written in JS using React, Angular or similar.

So maybe the frontend and deployment has changed. The rest probably not so much.

Java versions 8 and 11 are by far the most common.

Lambdas were introduced in version 8.

[throwaway4good]

If you ignore the way frontend is made (JS + rest api ws. server-side rendered html) and how stuff is deployed (containers vs. war-files); amazingly little has changed in Java the past 10-15 years.

[cimi_]

We have a multi-project gradle build, all our code is in Kotlin, we use micronaut as our base framework and we use IntelliJ as our IDE - this setup has worked great for us over the past year.

[fulafel]

Many use other languages on the JVM. Scala, Clojure, Kotlin etc. Besides the naked functionality, the language communities and cultures have their varying strengths. Eg quality of answers or libraries you easily find.

The years long constant stream of deserialization vulnerabilities, like yesterday's Spring RCE, are also largely absent from other JVM languages.

[rvcdbn]

Bazel, ErrorProne, Dagger, AutoValue, IntelliJ

[KronisLV]

IDE: IntelliJ IDEA https://www.jetbrains.com/idea/

Nothing else seems to come close, they have a Community version, nowadays Eclipse and NetBeans both feel slow but Visual Studio Code with Java plugins lacks refactoring abilities one might expect in an IDE for non-trivial projects. Also, if you get the Ultimate package of their tools, you get all sorts of other useful tools, personally i also enjoy WebStorm and DataGrip for developing front end stuff and working with databases in a separate tool.

JDK: whatever the LTS release of JDK is at the time, based on the kind of work that i do (so JDK 17 now) https://adoptium.net/

As long as you're not stuck with JDK 8, you should be fine in regards to this. But you can definitely enjoy some speed improvements across the releases as well as new language features as well as things like helpful NullPointerException messages. Personally, i'd sometimes also look towards OpenJ9 as an alternate runtime (due to lower memory usage), but that project's future isn't very clear (at least in regards to available container images) last i checked.

As for frameworks, pick one of the following:

  - Spring Boot: mainstay of the Java ecosystem, has a really large amount of integrations and the Boot version also simplifies getting up and running, about as safe of a bet as Rails for Ruby or Django for Python
  - Dropwizard: probably the closest competitor to Spring Boot in my eyes, but is a more loose collection of a variety of pretty much "standard" libraries, has decent developer experience
  - Eclipse Vert.X: pick this if you want to work with reactive programming, last i checked it didn't feel quite feature complete, but the performance numbers speak for themselves, even if it feels a bit niche
  - Quarkus: another modern option that's tailored for the development of performant web services, got a lot of hype in conferences in the past few years
  - Helidon: pretty similar to Quarkus as far as i'm aware (at least as far as the positioning in the market goes) so figured i'd also mention it

In practice, you're most likely to see Spring Boot in existing projects since it's so boring and dependable, though perhaps sometimes you'll also run into the legacy Spring framework (which can be a pain to deal with) or even some of the other ones.

Here's a rough performance comparison if you care about that sort of stuff: https://www.techempower.com/benchmarks/#section=data-r20&hw=...

Build tools: personally, i just use whatever Docker images to base the apps on when available and something like Ansible when not. For the actual toolchain, Maven is still pretty dependable, i guess Gradle is also okay. You might occasionally run into tools like Bazel or Jib, experiences there might vary.

App servers: if you need an application server for some reason (e.g. deploy app as .war), Tomcat is still a good option. If you need the EE functionality (e.g. Java EE which is now Jakarta Java), you might need to reach for something like TomEE or Payara Server, though i haven't needed to do that for a few years at this point, since Spring Boot embeds Tomcat and that is good enough for almost all projects.

[tralarpa]

> Nothing else seems to come close, they have a Community version, nowadays Eclipse and NetBeans both feel slow

After not using Eclipse for 10 years, I had to use it again last month for a very large existing project. I was pleasantly surprised. It felt faster than IntelliJ.

[mnkmnk]

What’s the JDK version people use today? My company’s stack is still on java 8.

[valbaca]

Most of our old services are still on 8, slowly migrating those to 11. Sometimes it's trivial, other times it's a pain.

Anything new is at least on 11 and 17 where possible.

[itpragmatik]

- IntelliJ

- Java 17

- SpringBoot 2.6.x

- Hibernate

- Maven

- MySQL or Postgres

- Liquibase

- Swagger/OpenAPI

- Docker

[seymon]

Which JDK distribution is used today? There are so many to choose from.

[omgmajk]

IntelliJ Idea for sure.

[sgt]

Also using IntellJ. But how is the landscape with the other IDE's these days - is NetBeans keeping up?

[watwut]

I am using it now because the team is using it, but cant figure out in which way it is supposed to be better then Eclipse. It looks somehow better, but it seems strictly inferior in terms of what it does for me.

[darksaints]

After doing some "modern" spring boot / hibernate, I came away wondering how anybody ever thought that was a good idea. The switch to kotlin with ktor took less than a day, and my sanity has been preserved.

[Hardik_Shah]

Over the last five years, the Java Platform has seen a tremendous amount of evolution and improvement in a variety of areas, including: language features in Java, Kotlin, and Scala; Functional Programming; dev environments; test workflows; Reactive; Stream processing; and distributed data.

[soco]

Is Scala still in trend?

[ActorNightly]

Personally, after the log4j fiasco, I wouldn't touch Java.

The standard ecosystem setup is to use all the major 3p libraries for all your functionality (Jaxrs, swagger, log4j, jersey, e.t.c) While this generally works, the ecosystem is full of holes (like log4j), and crappy behavior. You get things like "javax.ws.rs.ProcessingException: Already connected", exceptions which mask underlying issues like not being able to find the endpoint, or SSL certificate error, mainstream clients for things like Redis having issues with multiple connections and unable to switch to master nodes, and so on.

The core language itself is very "dirty" (Integer vs int, requiring a class for the main function, e.t.c). The standard way annotation processors add functionality is to basically write out java files, (or in the case of the ever so popular Lombok, they hack the AST). Because of how annotation processors are run, often times an error during annotation processing with dependency injection will result in very cryptic errors, often about things that were working before that you didnt change.

And on top of everything, jdb debugger is pure garbage, forcing you to use bloated software like IntelliJ for any decent functionality.

Yes, you can learn the ecosystem and its idiosyncrasies, or you could just write the thing in Python or Node with a much more efficient workflow. Network latencies dominate the processing speed these days, and infrastructure is cheap compared to developer time.

[haveyoubeen]

Pythons indentation errors and complete lack of variable types make it a kids scripting language at best. It is only useful for quickly cleaning data up for clock watchers at Mega Corp XYZ and its libraries like scikit learn which are kinda cool but it's best to link some python scripts and do everything else as a Java project. Data science cleaners / janitors are usually very limited energy wise from fapping and have that cuck squarish personality thing going on so they like pythons lazy approach to coding.

[dgb23]

> Network latencies dominate the processing speed these days

I want to see data on this. It gets repeated over and over but this doesn't match my experience at all. Am I crazy?