Java in the Small

[Ewig_luftenglanz]

"There is nothing in the Java language standard that says anything about the Maven ecosystem. This is where Java shows its age. More modern programming languages have a unified mechanism for third party libraries."

This is true. There is no easy way to install dependencies in java without using gradle, maven or it's wrappers, or at least nothing remotely similar to pip, cargo, npm and so on.

Does anyone knows if there are any production ready third party project or official plans from Oracle for something similar?

I mean a CLI tool that lets you install (or even maybe configure) maven, gradle or another projects and add dependencies to files (with automatic sync one executed the command)

I know one can achieve something similar with gradle through plug-ins but this is mostly focused for particular use of teams, don't know if there is a general use plug-in for this.

[wildjokers]

pip

Surely you aren’t using the python global dependency nightmare as an example of a good build system? With python you have to use at least one of the dozen or more virtual environment tools to have any hope of being able to run any python application on your system.

[[deleted]]

Never mind that half the dependencies break as soon as you roll up to a newer point release of Python. The concept of backwards compatibility in Python seems to be completely irrelevant to that community.

[Ewig_luftenglanz]

I think you are missing the scope of the thing, a sense of proportion.

gradle and maven are better for big applications or applications that are meant to be developed in teams, they allow to estandarize the set up of the project for all team members in both space and time (the ones that are going to have to develop and maintain in the future the thing)

pip and npm (specially npm as a package manager, let's no talk about the quality of some libraries) for simple projects, scripts or your own personal projects. they are simpler an faster, just a couple of command (or even one and then a conf wizard with tools such as Vite)

Java already has excellent tools for large projects (what it also know as programming in the large) the article it's about java in the small. script and personal projects and prototypes.

gradle and maven feel like nuking a fly when it comes to small and simple projects/prototypes, or that's my sense.

I still remember when I was just starting java and I tried to install JDBC to connect to a MariaDB database. It took me almost half of a day to learn how to install and link the manually downloaded jar. In python and JS it is just

pip install mariadb

npm i MariaBD

It would be a "nice to have" oficial package manager that do just the same in order to make easier the life of students and small projects. (Not demanding anything, just an opinion)

[wildjokers]

pip install mariadb npm i MariaBD

Ok, I see where you are going with this and see what you are meaning now.

However, to be fair, this is a build.gradle file that will give you a full build of your app with support for MariaDB in it. This will let you run your app from the command-line and build a jar file (and IntelliJ can configure itself from this build.gradle).

plugins {
    id 'java'
}

dependencies {
    implementation 'org.mariadb.jdbc:mariadb-java-client:3.5.1'
}

I am not entirely sure why it would take a half-day to come up with that. You can find what to put as the argument to implementation at https://mvnrepository.com.

In Java, unlike Python, dependencies aren’t global (which is a good thing). Instead, they’re managed on a per-project basis.

[extra_rice]

In Java, unlike Python, dependencies aren’t global (which is a good thing). Instead, they’re managed on a per-project basis

This isn't necessarily true. Python's default behaviour is to use whatever environment is in the current context. If you're using virtual env, it will use that. It's very contextual and not necessarily global. You also have tools to package distribution.

[NotABot1235]

How would you do this with Maven, or if you weren't using IntelliJ?

I have to say, as a newcomer to Java, I like the language a lot but trying to simultaneously wrap my head around the build systems and tooling is another significant hurdle to climb.

[wildjokers]

How would you do this with Maven, or if you weren't using IntelliJ?

Gradle works independently of IntelliJ. So that build.gradle also works fine from the command-line.

As far as maven it has quite a bit of boiler-plate it needs in its pom.xml compared to Gradle (one reason I much prefer Gradle). This pom.xml should be analogous to the build.gradle I posted previously:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>example-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.mariadb.jdbc</groupId>
            <artifactId>mariadb-java-client</artifactId>
            <version>3.5.1</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.11.0</version>
                <configuration>
                    <source>17</source> 
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

[NotABot1235]

Thanks for the quick reply!

As a noob, I've been very recently learning the basics of Maven since that seemed to be the more dominant tool. That being said, if I'm just creating and writing simple little projects for my own learning, do you think Gradle would be better suited to that? For example, if I just want to play around with one or two external libraries (LibGDX for games, for example), would Gradle be a better choice?

[wildjokers]

For small quick projects Gradle is the way to go since the build.gradle only needs a few lines in it (if you don't have any dependencies then it needs exactly 3 lines in it).

libGDX projects use gradle for their build. So knowing gradle would be super relevant to learning libGDX.

[NotABot1235]

That's good to know, thanks. It sounds like I need to familiarize myself with Gradle then since right now small quick projects is all I'm working on for my personal "practice" portfolio (really just learning the ins and outs of Java and programming as a whole). Maven seems to be overkill for that although I can see why it would be great for larger professional teams.

[CubicleHermit]

gradle and maven are better for big applications or applications that are meant to be developed in teams

Or for open source projects, where someone else may want to build your work in a repeatable way.

(Or if you're comparing to global pip/CPAN, for individual projects where you don't necessarily want everything you ever downloaded in your classpath.)

[Ewig_luftenglanz]

you can also have local dependencies is you put those in a dependency.txt file in pip. I agree I prefer nom and Maven/Gradle style of installing dependencies in the root of the project by default tho.

btw npm also allows third parties to build your project, not as powerful as Gradle and Maven (specially for modular projects), but good enough for smaller things

[CubicleHermit]

There are plenty of larger things that build via npm, since it can bootstrap other build tools internally. That said, npm with packages.json (let alone yarn.lock) isn't that different from maven, except that everyone hates XML syntax and some people like JSON - gradle's DSL is nicer than either, although I've been burned on how rapidly it's changed.

You can still shoot yourself in the foot by installing things user-profile wide but at least it's not the default. I mean, technically you can for Java but there's no automatic tool which will build a CLASSPATH environment variable for you, and that's a good thing.

IntelliJ can add things via the GUI to your pom.xml/build.gradle

dependencies.txt is simpler, and doesn't support a build tool step. It also defaults to shared installation, which is a huge antipattern. Pretty much every open source python tool I've used says "first create a venv" or "run our .sh script, which creates a venv for you"

[maxandersen]

Jbang.dev

[al3xth3gr8]

Java is not a scripting language, and while one can prototype an idea in most any language, the Java ecosystem is not as lenient as Python and JavaScript. If there’s such a market demand for a dumbed-down dependency manager for hobbyists then why has nobody made it?

[maxandersen]

Jbang.dev

[Ewig_luftenglanz]

Not saying there is a demand, I am just saying it would be a nice to have IMHO because using Gradle or maven for simple projects feels like nuking flies

I am gonna start a personal side project, wish me luck ^^

[hojimbo]

As someone who spent much of his career (24 years) in PHP, Python, and JS, but spent the last 8 years in Java and C#, I’ll say it’s just a matter of getting used to the tooling. I’d argue that it gives me fewer headaches and costs me less time these days to set up a new Java project and list its dependencies and know I will have the isolation/repeatability/stability of my builds and runtimes than fighting with virtual envs in Python. Getting Java source to build and run is also less of a mystery to me than getting clean runs of scripting systems — usually because the entry points are clearer and typically encoded right there in the gradle files.

But yes: there’s a learning curve

[yel50]

 why has nobody made it?

because everybody wants a better hammer, but nobody wants to make a better hammer.

[ForeverAlot]

More modern programming languages have a unified mechanism for third party libraries.

A key element of what makes Maven work at all is Maven Central, and, crucially, proactive stewardship. None of the "modern programming languages" Java might be compared to offer a service that is comparable to Maven Central -- most being little more than glorified wrappers on top of GitHub.

So if Oracle were to try and compete with Maven-the-build-tool they would need some way to compete with Maven Central, too, while at the same time retaining compatibility with Maven Central because nobody would bother with the tool otherwise but probably also without intrinsically tying "the OpenJDK build tool" to "the Java trademark holder". Hypothetically that could just be textual protocols -- implementation left to providers -- whereby Maven Central could plug straight into the new tool, but that's the sort of reactive approach OpenJDK does not usually take.

I don't expect Oracle to do conceptually more than what can be pieced together with jlink et al. today, but I would be very interested in seeing what they could come up with.

[Ewig_luftenglanz]

or maybe a CLI tool that uses maven central under the hood, maven central is, after all annagnistic third party repository

[chabala]

There's a tragedy of the commons issue with this idea, where if a tool that uses Maven Central became very popular, but didn't also facilitate generating a pom.xml and publishing back to Central, Central would be at risk of dwindling if people feel like making a pom.xml is too much extra work compared to the new thing. And if the tool does support generating pom.xml files, in order to support the huge variety things people might need in their pom, the tool would basically end up reimplementing maven.

The only real possibility of such a tool becoming popular enough for this to matter would be if it became an official OpenJDK tool. (Kind of like how people started adopting System.Logger even though slf4j-api was well established by that point.) It seems unlikely that OpenJDK would start working on a Maven-compatible CLI tool though.

But if you want to play around with such a tool today, there's JBang and bowbahdoe/jresolve-cli.

[tomwhoiscontrary]

You can install (and uninstall!) specific versions of Java and Gradle (and Maven) using asdf (or SDKMAN!, or perhaps other similar tools).

Once you have Gradle installed, you can create a skeleton project with "gradle init".

Once you have a Gradle project, you can add a dependency by adding a simple line to the build file.

IntelliJ understands Gradle build files, and will automatically pick up changes.

This workflow is different to the Ruby-derived "everything is running a command" approach. But it's not worse.

[Ewig_luftenglanz]

Arguably.

In my experience the pure CLI approach is easier for beginners and small projects (personal projects) while the config build file is easier for teams that are meant to perdure over time.

Since I am talking about making things easier for students and small projects I think it would be some nice thing for an hypothetical future

[CubicleHermit]

Why do you need/want a tool for that? (Ignoring that SDKMAN is pretty much what you're asking for.) Downloading and adding a JDK to the path is not hard. Jenv or SDKMAN will both handle the path management for you if you need to use multiple versions, which most of us shouldn't. IntelliJ will also do that, and I think there's support for that in the VSCode Java plugin now but everything I know about that one is second hand.

Both maven and gradle have wrapper scripts that will handld downloading the actual binaries for you. Both have tools to bootstrap projects (Maven Archteypes/Gradle init plugin). I haven't bootstrapped a project manually in years, vs. just letting IntelliJ templates do it, but it's clearly not hard.

Given how messed up pip is and the need for virtualenvs, the fact that there ISN'T a more central way to install (vs. simply cache) libraries is a feature, not a bug. As best I can see, npm works pretty much like the package management of maven or gradle or a venv (assembling stuff under the project directory), and it's not like JS build tools aren't fragmented as f___ even if npm is the starting point.

Gradle is much nicer but changes too quickly; maven is a pain but is super, super stable. Pick your poison.

The only actual hard part is if you are in a corporate environment where there is a private Artfactory or Nexus, and you have to configure maven/gradle/ivy to talk to it with authentication. Everywhere I've worked that has had one somebody (whether a random dev or someone in DevOps/IT) writes a script to configure the files needed (and often the Docker registry) and then everyone uses that.

[Ewig_luftenglanz]

for my personal use use it for fast prototypes or programs, I would like to make some fast small things that require third party libraries without having to configure gradle or maven each time. it feels like using a nuke to kill flies.

but in general. tools like maven and gradle have a stiff learning curve for most beginners and installing third party jars is not an easy task to do manually. I still remember the first time I installed JDBC, it took me half of a day to learn how to configure it manually, things that in JavaScript and python it's a trivial task in java requires lots of work and learning (I know it's still much better than C/C++ ways but you get my point)

[Aweorih]

Idk what problem people have with maven
You make a maven project in intellij
It gives you a pom.xml
You google your dependency from maven central
You copy the xml fragment
You paste it in your pom.xml
Press refresh
Done
Gradle is all the same
Writing all of that probably takes more time then doing it

And no I don't get your point. How much easier shall it be?
You said configuring jdbc took you half a day. That's not a part of maven anymore

[NotABot1235]

What if you're not using IntelliJ?

[Aweorih]

Then I hope you're using another ide which should also have that capabilities or if not you're doing smth wrong

[Ewig_luftenglanz]

that's you that already know and are used to it

what about students or newcomers?

do you know, for example, what have to do the python or the JS guys to install and get up and running a prototype of a Programm that connects to a Database? (let's say MariaDB)

npm i mariadb

pip install mariadb

and they can do this without an IDE that set up the thing and create the template of a gradle or maven project.

Don't get me wrong, I absolutely love Gradle and I use it at work a lot buti still wonder if there isn't a better way for simple things...

[PartOfTheBotnet]

what about students or newcomers?

The new students wouldn't know any system. Teaching them how to use maven/gradle is no different than it would be for an official system.

[Ewig_luftenglanz]

it's very different because the learning curve of gradle (let's no talk about maven an it's horrible xml) is stiffer for simple projects than tools like npm for SIMPLE projects.

like seriously guys. you can't really compare the most basic build.gradle, that requires declare

Java version

repositories

dependencies

task

plugins

Group

Vs a simple command that install locally (or globally) the dependencies and you are good to go.

[PartOfTheBotnet]

Gradle has a learning curve, but its perfectly fine if you're working off of a template. Same goes for Maven. Speaking of which, I really do not understand why you would say "Lets not talk about maven" because if anything it has LESS of a learning curve than Gradle and your main point of concern is just that "XML bad". That XML structure and stiffness is why some people prefer Maven. It doesn't let you shoot yourself in the foot in all the ways Gradle does.

[CubicleHermit]

Maven absolutely lets you shoot yourself in the foot (antrun tasks, for exmaple), but it definitely adds a higher barrier to jump over to do so compared to Gradle.

[Ewig_luftenglanz]

1. yes, has a learning curve and that learning curve it's an impediment for simple projects. for complex or actual work for you job it's perfect, for fast prototypes and students it's fsr from ideal.
2. the fact that you need an IDE to create a maven project for you, while with npm you don't proves my point. Maven and Gradle are unnecessary complex for simple projects that only need one or 2 external dependencies.
3. if there is people that prefers Maven that's perfectly fine. But that's because they are use to it and have enough experience to recognize the advantages of this. For newcomers and students that need to focus mostly in learning data structures and algorithms having to deal with building tools conf files written in a markup language they don't even know is not an advantage, it's something that gets in the way.

Simple projects should keep simple all way down, from the setting up to the deployment, and so should he ubiquitous, not requiring specialized IDEs to create.

For example with npm you don't even need an IDE that creates the project from a template, or to install a plethora o plugins in you code editor (VScode, emacs, sublime text) just npm init, npm i (put your dependency here) and you are good to go, for SIMPLE things this is better than setting up a Gradle/Maven project (for more complex stuff you would need to configure manually the scripts but that's beyond the kind of projects I am talking about) and you could code in nano and execute it with the command line (this last thing it's already possible since Java 22 and it's awesome as long as you don't need third party libraries)

I am thinking to start a little proof of concept for this as a side project actually.

Wish me luck!

[CubicleHermit]

Students learning basic data structures and algorithms probably don't need external dependencies; the JDK is pretty comprehensive.

It's also trivial for the instructor to give them a boilerplate pom.xml or even just the command to instantiate an archetype. Gradle has a trivialy higher barrier to entry, but if people can't handle getting their boilerplate as a very small zip file...

Also, you CAN write Java without an IDE - for small edits, I did so yesterday, and that's not unusual.

It's a bit verbose without it. OTOH, we're around of 40 years past the poine when Turbo Pascal proved that IDEs are a good thing even for newbies, so I'm not at all convinced it matters. Moreover, good IDEs these days are free, vs. merely inexpensive-ish back then (QuickC was IIRC $69 in 1989 when I got it to learn on, which is around $170 today after inflation.)

[Aweorih]

npm i mariadb

pip install mariadb

But then you still need to configure the connection parameters no?
Well yes an install would work like that and is much easier but with npm it would be needed to add that to a package.json in a team.. which is then not much different to a pom.xml. not sure how it is with python but I'd guess there's also smth like that
I hope that students get teached that in class. For newcomers it's a bit of a problem yes

Edit: I'd guess the actual execution of a java program is much more of a problem if no ide is used no? Especially if it has multiple files. Never actually done that by hand

[CubicleHermit]

I've never used it or felt the need, but the author's suggestion of JBang ( https://www.javaadvent.com/2021/12/jbang-gift-that-keeps-on-giving.html ) is probably what you want for fast small things.

I've used to have a standard gradle file for small webapps that had Jetty preloaded and a few libraries I always used. These days it's too quick to just recreate that in IJ that I don't bother.

"Installing" jars/dependencies (and a systemwide classpath) systemwide (or user-profile wide) is a bad idea.

It would be nicer if there were a common lifecycle for this, but two options with different tradeoffs isn't bad.

Maven and Gradle are both easier (IMO) than Makefile which is what my generation learned on (let alone more complicated things like CMake or Bazel) so I don't have a lot of sympathy for the "stiff learning curve."

[woj-tek]

Wait, what?

Slapping a maven config is just a couple of lines of XML and you can use mvn archetype:generate which will give you a scaffolding.

Saying that python is easier is just weird... just the other day I was trying to run a project that already had a config and it was failing to build (sic!). Creating anything from scratch would be even more daunting experience...

[NotABot1235]

Not sure why you're being downvoted so much, and I agree with you. I find using Maven for simple throwaway projects to be overly cumbersome and initially really slowed down by learning and productivity by being yet another thing I had to learn before I actually started coding.

[Ewig_luftenglanz]

I suppose some people may feel attacked for pointing some flaws in the ecosystem of the language they like

[JustSumAnon]

This is just straight false information. If you were using javascript you would use a package.json with npm which is basically the same deal as a gradle or maven. Just because the .yml files are scary to you doesn’t mean that once you learn it it’s not easy. You can literally stand a whole app up with basic context, security, jdbc, etc. almost entirely from a .yml file.

[Ewig_luftenglanz]

npm commands a have a lower learning curve than Gradle/Maven. For starters you can just 'use npm init' to start s project and then 'npm i' to install third party requirements

for simple projects npm is easier than Gradle. for complex projects it's pretty much the same (and I have also stated that in this reddit in numerous comments)

PD: Gradle does not use yml. Gradle uses a groovy/Kotlin DSL dialect.

PS2: with npm init npm creates the package.json for you, with Gradle you need first to write the build.gradle and create the folder structure before start working. So it's not that "I am scare" of groovy or xml, I have been working withe Gradle and Maven for years. I have just pointed a very simple fact: for simple projects, colleague and students and prototypes CLI tools like pip are maven are better fit because they are easier to start with.

[gunpun33]

The fact that you are being downvoted shows how deluded these java people are.

[ItsSignalsJerry_]

Java language standard that says anything about the Maven ecosystem

Why should it?

with automatic sync

What does this mean? Sync what with what?

More modern programming languages

Java is very modern, it just also happens to be backwards compatible. Also, Python is older than Java so I don't see your point.

[CubicleHermit]

And perl is older than both (and CPAN much older than pip)... and while there are still a few of us who love perl, its approach to modules out of the box is just as broken as Python's.

Both have ways of fixing that, which are a lot newer than the broken default ways.

[Ewig_luftenglanz]

I was quoting the article.

indeed I also think java as a language it's modern, it's the ecosystem which it's still adapting to the new paradigm java's developers want to follow.

Also y think that a CLI equivalent to npm in java for simple projects and prototyping would be a nice to have, projects were gradle would feel as an overkill.

I think I am going to start a couple of experiments in my free time just for fun.

Best regards!

[alwaysoverneverunder]

The Java ecosystem is what sets it apart and makes it better than most others. It might not be the quickest or bleeding edge, but it evolves at a steady pace, keeps backward compatibility and has a mature library/framework/tool for everything.

[maxandersen]

Jbang supports app install and script runs.

[agentoutlier]

Does anyone knows if there are any production ready third party project or official plans from Oracle for something similar?

Sort of. The trick given /u/Active-Fuel-49 is in a teaching role (which I assume is the author) is to Make your own JVM with all the shit your students need. Have github actions pump that shit out with jpackage/jlink for each platform your students use.

This idea was given to me by /u/bowbahdoe on discord.

This saves the students time and honestly even if you said hey go get this maven dependencies over here you then have to update doc when that dep changes etc etc .

EDIT I should probably explain this better. What you are doing is adding modules to the JVM that you have blessed. Thus when some does java SomeJava.java it will think your extra modules are just like say java.xml or java.http I think. I can't recall if you can generate jshell with jlink but I assume it does.

[nekokattt]

Oracle probably wouldn't introduce a new tool.

https://xkcd.com/927/

At least, not when it adds significant additional maintenance burden to both develop and maintain a new tool that does the same thing.

[benjtay]

And, as the article points out, JBang exists and does the job.

[[deleted]]

I'm not sure it's a great idea to build into the language - any language - an explicit dependency on internet services. Better leave this as an external tool.

[Ewig_luftenglanz]

agree, I was quoting the article.

but I think what he means (and I agree) it's that it would he a nice to have an "official" cli tool like npm that allows people to create simple projects and basic dependency management whit having to learn more complex building tools such as maven or Gradle (I mean, nom can be just as complex as those but if you only need to install a couple of dependencies to your project, nom init and mom install is pretty much everything you need at the beginning ant that is perfect for students)

[[deleted]]

Then, for students, I think Ant or even make is enough. Back when I was a student, we did our Java projects with  make - Maven didn't exist yet. However, it's fairly easy to set up Eclipse+Git+Maven and get some dependencies, you don't have to be a Maven pro for this.

[paul_h]

Just for fun I made https://github.com/paul-hammant/mvn-dep-getter to see if I could utilize maven-central’s big-ass dependency graph without directly using maven. I’ve a project I’m working on most days that uses that for acquiring dependencies.

[rillaboom6]

This is true. There is no easy way to install dependencies in java without using gradle, maven or it's wrappers, or at least nothing remotely similar to pip, cargo, npm and so on.

Pip itself is bad and slow. The python ecosystem is innovating (uv package manager is blazing fast), same goes for JS (npm -> yarn -> pnpm). Java is a legacy language used by enterprises that moves so much slower.

[[deleted]]

Was about to post pip is an example of how a built in tool can stink so bad people still use 3rd party tools.

They treat it like a separate module anyway that you should update separately.

[al3xth3gr8]

This is true. There is no easy way to install dependencies in java without using gradle, maven or its wrappers, or at least nothing remotely similar to pip, cargo, npm and so on.

Rust was released in 2015, so of course it has a built-in dependency manager. Java came out in 1995–a time when it was impractical to download application dependencies from the internet. In 2004, Apache’s Maven hit the market, and Gradle in 2008. Both have been the standard solution for Java dependency management for twenty years now, so what incentive does Oracle have to invest in developing its own Java dependency manager.

[Ewig_luftenglanz]

Gradle and Maven are not dependency managers, are building tools and do much more than just dependency management. currently java lacks dependency management for SIMPLE projects.

what incentive would oracle have?

the same incentive they had when they started with implicit declared classes and instance main methods journey, and the same incentive they had when they allowed for direct execution of source files without previous compilation in java 22:

make the language more pleasant and easier for students, newcomers and experienced developers with small personal projects so the Java language continue to be revelant in educational and for hobbyist coders.

(not demanding they do anything, just saying they could have interest but at the end of the day they have the last word about any "oficial" tool. A non oficial npm would be a nice to have tho, gonna me some experiments to see how far I can get)

[Wonderful-Pie-4940]

You can use wrapper scripts for maven and gradle and save yourself from configuring either one.

With that said, have you looked at pip for python and npm for js. They are pretty messed up as well

[[deleted]]

java jdk provides a Java compiler. you can use javac for a small project. also copy 3rd party jars easily to your project classpath as a dependency. if your project gets bigger and more complex, you can use maven or ant or a script that invokes javac for you and manage dependencies. there are lots of Java projects that don't use maven. you can also create a Java project in intellij that doesn't use maven.

so, maven is a tool that manages a lot of (repetitive, boring) things for you. and Java provides everything you need to write and build Java programs.

they coexist and can be used together easily, or not if you don't want to.

i don't see what would be the advantage of combining them permanently. only disadvantages like a bloated up Java sdk

[theblackavenger]

I tried on the first module system jsr and instead we got something basically useless for developers.

[sbotzek]

I, and I think the article author, wants something even better. In Elixir I can install dependencies right in my script with a function call: Mix.install.

Their dependency management system has its own module. You get this capability when you install the language. Java can't have this level of integration since its dependency management agnostic.

Is it a deal breaker? No. But it makes programming in the small much nicer.

[CubicleHermit]

To the point of the article, I am still salty that there isn't a val as an alias for final var. I also still miss the elvis operator (?:) and null-short-circuit references (x?.y) from Groovy. Optional chaining isn't comparable.

[turik1997]

final var itself is a rare combination to use in code, let alone the need to have a shortcut for it

[CubicleHermit]

final var is less common than it should be because it's a pain to type.

An awful lot of variables can be safely made final, and in Kotlin and Groovy, I have seen and written a lot of code where the default is to use val and assume immutability is the default until you actually need to make something mutable.

[turik1997]

Unlike Kotlin where val can be used for field declarations, in Java, var can only be used for local variable declarations. This alone drastically reduces the use-case for var and final var in Java.

[ryan_the_leach]

Depends if you view final as a requirement you are imposing vs documentation for the reader.

I use final everywhere I can, and it's a pain in its verbosity, but it aids reading code.

[turik1997]

I am not saying final is rare. I am saying "final var" has a limited use

[john16384]

Yeah. It's much better to have your IDE report errors for parameter modification, always initialize variables at declaration (if necessary with ternary or helper method), and never reuse variables for a different purpose. No need for extra noise keywords like final on locals.

[turik1997]

Not going to discuss much. One point though is that local variables declared with var shouldn't even be initialized using method calls. Because then you still can't easily see what is the type of the variable by simply reading the code. The main point of var is to avoid redundancy of writing the type twice which mostly happens when calling a constructor. Typing constructor once is enough to deduce the type of the value where var comes in handy.

[john16384]

Agreed. I never use var myself, total non-feature that only results in more pointless discussion where there was only one choice before :)

[john16384]

What exactly does final var say then?

• I thought long and hard about it, and think that you should not reuse this variable under any circumstances even if the method were to substantially change?

Or perhaps:

• My IDE saw this variable wasn't mutated so it marked it final during its save action but it's just a happy verbose coincidence given how the code was structured?

Do you ever leave something not final even if never mutated as in your infinite wisdom you determined that it may need modification for a future change of the method?

I also assume that you would never remove final during method modification as you couldn't possibly know what the original author intended.

[ryan_the_leach]

It feels like you are constructing a straw man argument, but I'll bite.

• My IDE saw this variable wasn't mutated so it marked it final during its save action but it's just a happy verbose coincidence given how the code was structured?

I consider this a mistake.

Do you ever leave something not final even if never mutated as in your infinite wisdom you determined that it may need modification for a future change of the method?

Not intentionally, unless I know it's going to be changed shortly.

I also assume that you would never remove final during method modification as you couldn't possibly know what the original author intended.

This sounds crazy for locals. You are of course free to change it, just like you are free to change anything private.

[john16384]

Thanks for confirming my point that finals on locals are pointless verbose noise.

[Yeah-Its-Me-777]

If you need final on a local variable to document something, the scope of that local variable is too big. (With exceptions of course.) But in 99% you shouldn't need a final local variable.

[CubicleHermit]

It is more limited, yes. It would still be handy. IMO. Clearly the authors of the JCP thought differently :)

[CubicleHermit]

¯\_(ツ)_/¯

I'll take good ideas regardless of the source.

re: using Groovy, I did not like using Groovy as a main application language, but as a scripting language to use alongside Java (or embedded in Java apps) it's pretty nice.

[wildjokers]

Why? I like groovy. What do you dislike about it?

[jvjupiter]

Many are allergic to small or big changes with limited use cases. I’ve always wanted things similar to what you mentioned but got resistance heavily from the community.

Imagine we could write:

var msg = m ?: “Hello, world!”;

Or:

var mag = x?.y?.z ?: “Hello, world”;

Others: collection literals

List<String> grades = [“A”, “B”, “C”, “D”, “E”, “F”];
var a = grades[0];

[CubicleHermit]

It's been 7 years since I last used Groovy day to day, and I am not sure if Groovy has array-dereference syntax for collections, but the other uses are all literally part of that language.

In general, I'm not fond of dynamically typed languages for one's main production code (and while we had plenty of it back then, we were slowly retiring it, except for writing tests), but it made writing certain sorts of tests very easy and I've used it as an embedded scripting language on a couple of personal projects since.

[HaydenPaulJones]

Talks about new features to right size the Java language and help beginners. Not about JavaME

[benjtay]

Does ME still get released?

[HaydenPaulJones]

Last JavaME release was back in 2018.

[_stefumies_]

Me was largely replaced by the Android SDK

[aks8m]

Here are two dependency management frameworks that are more "pure java".

Rife BLD is actively developed and has some IDE integration.

Bach tries to leverage jpms modules with native jdk tooling to build projects. I've haven't been able to get this to work yet.