1JPM: A Maven/Gradle alternative in a single Java file

I like the clever use of the "java prog.java" style.

I don't know how many folks know, although its been there for a bit, that you no longer have to specifically compile single file java programs.

You can just run them with with "java prog.java".

(Honestly, I haven't used the technique myself, still old school -- even with silly small x.java tests and such. Muscle memory and all that.)

As much as I hate adding more build tools to the Java ecosystem this one is pretty interesting since it is entirely Java based and version controllable without any additional dependencies to install. Obviously this won't solve all build problems but its simplicity is attractive.

(my hate for new build tools https://javarants.com/why-your-new-jvm-build-tool-is-making-...)

It doesn't handle transitive dependencies. So it's only a "Maven/Gradle alternative" to the extent that you don't need those. Enjoy!

This would have interested me before wrappers for Maven and Gradle became common. Now that you can check in wrappers and easily upgrade the build tool version I don't see this being worth while for general use. I could see it being useful in situations where you needed full code auditability of everything involved in the build process but I've never run into that requirement in my work.

So given that its intended mode of use is to be copied into another project and modified ... when would this maven build file in it be used? Also, I don't see that the dependencies (e.g. their `jlib`) actually get used.

https://github.com/Osiris-Team/1JPM/blob/main/pom.xml

Isn't this the exact opposite of what you want security wise? To even read the most basic project metadata (project name, version, deps, ... ), you have to run arbitrary in project code. So you have to do a code review of the project file before you can even open the project in your IDE. Programmatic project scanning is right off the list.

Maven has plugins for practically every conceivable use case - if I have to implement all that, this single Java file will become another giant file that will bring its own can of worms minus the advantages of the Maven ecosystem.

There is also another similar tool for building projects with Java code

https://jeka-dev.github.io/jeka/tutorials/build-projects/#ex...

https://jeka.dev/

I love seeing small Java projects like this and I always enjoy reading through the code.

On build tools: I don't actually mind Maven: I use a proper editor that can read and understand an XSD schema. But if it weren't for that I'd totally understand why people dislike it!

To those who say that it's not a good idea to use a full programming language for your build scripts.

Gradle uses "a full programming language" and I hate it but I have to use it for Android projects. Debugging Gradle problems is as fun as you'd imagine. There's a lot of dark matter in your build scripts that you don't see but that influences what happens. And because Android tooling is a clusterfuck ever since the demise of Eclipse+ADT, any change you make to your build process runs the risk of the entire thing exploding in your face.

This one is at least fully predictable, self-contained and doesn't randomly download 150 MB of crap when you're on a slow coffee shop wifi. I'm gonna try it sometime.

You can quite easily get by with the standard JDK tools (javac, jlink, etc) + a tool for fetching dependencies, such as https://github.com/coursier/coursier or https://github.com/bowbahdoe/jresolve .

As someone who doesn't dabble with Java too often, this looks nice. I do cross-platform mobile work from time to time and whenever I pick up Android I end up bashing my head against the wall with all the Maven/Gradle stuff. I'm sure it's intuitive when you're using it a ton but it always feels overcomplicated to me.

I remember seeing a single file "build.java" from Cliff Click a while ago. I wonder if he's still using that technique.

It took a while to find an example:

https://github.com/edwardw/high-scale-java-lib/blob/master/b...

How is it different from: https://rife2.com/bld

I hate reading documentation too.

Oh I expected to see a Java project with a single Java file inside, glad to see it’s nested in 3 folder levels. Java never disappoints

I'm fascinated by one file solutions.

Anyone have more examples?

Well, thanks for reposting from Reddit! Got way more attention over here than there.

This is cool. Even if we can't use it, it's cool to see innovation in Java build tools.

And then there's me, still preferring make + @argfiles like a madman :p

build systems logging libraries application frameworks

Every dev at some stage early in their career always thinks that they can create a better one.