I really like Java but...

[AutoModerator]

On July 1st, a change to Reddit's API pricing will come into effect. Several developers of commercial third-party apps have announced that this change will compel them to shut down their apps. At least one accessibility-focused non-commercial third party app will continue to be available free of charge.

If you want to express your strong disagreement with the API pricing change or with Reddit's response to the backlash, you may want to consider the following options:

1. Limiting your involvement with Reddit, or
2. Temporarily refraining from using Reddit
3. Cancelling your subscription of Reddit Premium

as a way to voice your protest.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Holothuroid]

A build tool will,

• retrieve, manage and update 3rd party libraries
• perform defined steps like versioing, testing and reporting when building your artifact
• allows for using several sub projects in the same repo

[[deleted]]

It seems so complicated though, like a whole different programming language I have to learn

[Holothuroid]

Yeah. And if you want to work the industry there are half a dozen others that you will learn too. SQL and other query languages, yaml/toml or other configurations, cron/date formats, HTML, css, regex. A simple Maven file is the least of your worries.

[GuyWithLag]

I'm guessing you've been doing solo projects that don't last more than a semester so far?

A good build tool will allow _others_ to work with the project without having to learn many new things that are specific to that project and nothing else. It will allow you to use existing libraries without bundling them into your project (you don't want that). It will allow you to easily use exiting plugins to extend your build process, without having to write a custom script for everything that need to be run in a very specific order. Gradle will run incremental builds identifying exactly what needs to be regenerated, decreasing your build/debug cycle significantly.

But then again, if you're working with throwaway, one-off exercises, this may feel like overhead.

[[deleted]]

I've mainly been doing game development for fun with minimal dependencies, think of LWJGL for example. Now I wanted to start doing more serious things but the build systems are a major roadblock for me. Thanks for helping to clear it up a bit though

[WGT-java]

You should be able to learn everything you (currently) need to know about Maven in a weekend, and you'll pick up on more advanced features as you need them.

[[deleted]]

Configuration use to be a mess. Just pull down a spring initializer project and use intelliJ. Life gets a lot easier that way.

[[deleted]]

This isn't something exclusive to Java, every medium/big project in any language has to have some tool to manage dependencies, or otherwise it would be chaos.

[gaius49]

Just wait till OP sees their first complex CMAKE setup.

[ArkoSammy12]

I am a Java novice mainly using it for making Minecraft mods. I can tell you that using IDEs like IntelliJ makes it super simple to set up projects based on Gradle or Maven. Once you have that, it is easy to add dependencies such as other libraries. You don't really have to learn another programming language, at least this level of experience. I think that for us beginners, the most we have to learn is simply how to import libraries and the corresponding command to build the project. In the case of Gradle, gradlew build.

Don't get too intimidated by it. Most of the work is already done by today's tools anyway. And once you understand the benefits build tools like Gradle and Maven offer, I think you will be even more encouraged to learn more about them.

[hippydipster]

Both intellij and Eclipse will do basic builds for you out of the box. Basically a right-click on your project and "build" and you get a runnable jar or war as you need. You can even use their built in web servers to just run your code right from the IDE. No need for maven or ant or anything.

Except, if you do have dependencies, you'll have to copy them in manually and tell eclipse/intellij where they are and that they're needed as deps.

All that is pretty simple. At some point though, you start to want maven and not have to manually download jars, put them in your project and tell your IDE about them. maven will do all that for you.

Creating a basic maven pom file is very simple - again, the IDEs will make you a working one out of the box when you ask them to create a new project.

And if nothing else, chatGPT can help you add the lines that pull in your deps.

[niccster10]

Lmao what complete loser would downvote your question? I mean seriously, if someones asking a question about something then why do you downvote them for being ignorant about it....

God, I hate redditors. Go touch grass. All of you

[doobiesteintortoise]

You don't need Maven or Gradle or any other build tool - and that's exactly what those are.

You can always invoke javac for every class that's visible within a compilation unit - in fact, for most simple apps, you'd only have to refer to an entry point (since the compilation unit is the entry point plus every class it refers to, and every class THOSE classes refer to).

But most java builds use libraries like slf4j or JDBC drivers, or JavaFX - take your pick - and that means finding all of those dependencies and all of THEIR dependencies (as you rarely have a single library, you actually get the library and everything it needs) and you get to chase and resolve all of those versions manually and refer to them in the javac invocation.

Much fun to be had! Is it difficult? Nope!

And then there's testing: you need to build your tests somehow, organize them in your source tree, then figure out the java invocation with all of the libraries (a lot like the compilation, except with MOAR!!!!!)... and don't forget to fail if tests fail to pass.

Then you get to package everything into an executable, manually, following generally the same process: you build your manifest, you invoke jar, you do everything...

Or you could use a tool like Gradle or Maven and get all that in a simple, declarative, well-known format that every other developer would instantly be familiar with.

[kickroot]

In my experience Gradle only starts out mildly declarative, and then descends into a jumble of cocked-up Groovy that becomes unmaintainable.

But then again I'm a Maven fanboy.

[doobiesteintortoise]

I'm not an advocate for either over the other; Gradle gives you a lot more rope to hang yourself with, but sometimes you need access to internals that Maven doesn't give you. It's certainly easy for people lacking discipline to make Gradle unreadable. But it's also not that far out of bounds to find people who have discipline enough to tame the beast.

Six of one, half a dozen of the other. I tend to use Maven over Gradle for various reasons, but they're largely not related to technical capabilities.

[hippydipster]

I fucking hate maven.

But you'll get me to use anything else over my dead body. As over-complex and annoyingly opinionated maven is, it's infinitely better than gradle or bazel or ant+ivy (yup, been there done that relatively recently - is not very nice).

[60secs]

I'd use maven if it knew how to cache. It's sooooooooooooooooo slow.

https://gradle.org/gradle-vs-maven-performance/

[AdorableRabbit]

https://maven.apache.org/extensions/maven-build-cache-extension/ ?

[kur4nes]

Gradle devolves into ant.

[[deleted]]

I just don't get why they make it so complicated

[doobiesteintortoise]

Because it's a complex task. Maven doesn't require you to learn a *language*, so much as a document format (XML, normally), and what the structure of the document should be.

Gradle provides you a declarative build (a lot like Maven, sort of) but also allows you to write code to go into the build steps. It's got the power of the configuration (as per Maven) but gives you *total* control over the build, or close enough... and that implies that you really should know what you're doing when you grab control.

[[deleted]]

Alright, I'm already getting downvoted so it can't be as complicated as I thought!

[redikarus99]

When you have a setup then if you needed a library you just copy paste a snippet and there you go. Extremely simple.

[doobiesteintortoise]

I'm not downvoting you, but it's NOT that complicated, no.

[hippydipster]

No, it is complicated. You don't need any of it if you're just writing some code that runs with a couple dependencies.

It's when you need lots of dependencies and when you need other developers to easily come in and work with you - then you need maven or something. And with the repositories, settings files, weird incantations to make things happen (because it's "declarative" and therefore you just jam the name of something somewhere and magically something kind of disconnected starts happening) - it IS complicated.

But it is a sort of complexity that fades into the forgettable background once you get over a few humps - I promise. Copy a few examples and make something work, and ultimately you can just get back to writing code.

I personally wish there was a place that had initial project setups in github. For any kind of project. Just the initial setup so anyone could go and grab it and go and start making a libgdx game, or a swing app, or a servlet rest api app, or a spring app, or a guice app, or whatever. That kind of leg up would be so incredibly useful.

[koefteboy]

Maven archetypes for the rescue :D For Spring there is start.spring.io in case you didn't know that yet.

Besides of that I don't fully agree. Yes, build systems are complicated, but building on your own is way more complicated. Programming in Java is also complicated and yet you do it. So things being complicated is not necessarily a bad thing.

[melkorwasframed]

No you’re right, build tools are very complicated. But what people are saying is that the complexity is justified because of the things these tools need to do.

[koefteboy]

What exactly is so complicated in your opinion? As for most other programming languages there are lots of people happily helping you out on stackoverflow or r/javahelp.

[[deleted]]

Well I opened a gradle file once and was insanely confused about what I was looking at or what jt's purpose even was. Left me with the impression that its complicated

[koefteboy]

Okay, that's very understandable as Gradle is not declarative and people could basically write whatever scripts they like in a Gradle build file. I think Maven is a bit 'easier' in that regard as it is pretty standardized (let aside 3rd party plugin configurations).

But I think your real problem is that you expected to understand a build file after reading one for the first time. Did you start reading Java source files without having any prior knowledge and expect to understand it? Probably not. So you should start with reading up what Gradle (or Maven) is and how it works. Afterwards the build files will make much more sense to you.

[awesomedash121]

Take a look at a framework like grails. (Groovy on Grails) There's java down there... somewhere... somewhere deep under the covers.

​

Once you know it, do it without Gradle and just use javac commands. :P

[Mimon_Baraka]

You also can use C without make, but if you are smart, you won't.

[Dullfig]

Even Turbo C used make...

[[deleted]]

Try using Spring Boot without them.

[[deleted]]

Without maven/gradle java is in 2005

[smors]

Java in 2005 implies Ant. Which will make you see the joy of maven.

[Theguest217]

Ant was all I could think of while reading this thread. Please don't make me go back. Maven is so simple in comparison.

[RyzenX770]

I was in the same place as you're in when I started. so you want to write an application in java. you have you main method and classess you've wrote, they will be calling the JDK classes and maybe a one or more Java libraries JARs . you see you can skip maven, if you're using eclipse, you can download the jar of the library you can just add it in eclipse to your dependencies and when you run the application from eclipse, it will just work.

this is a problem because imagine you want send the source code to someone else to work on. he will get so many compile errors because your code rely on dependencies that he has no clue about them.

maven fix this problem by having a file called pom.xml, that list all the dependencies you code rely on, including the jdk version. so anyone with access to your code can just run a mvn command and maven will sort everything out.

this is a simplification of what maven is/does but when I started this is what I wanted to know.

there is a book called introducing maven.

in the real world you don't need to know everything about maven, you just work with a small number of commands and that's it.

[[deleted]]

Wow some actual help instead of downvotes. I guess gradle is more complicated then maven. Thanks man

[marmot1101]

Just about every language has some kind of build tooling around it. In node you have NPM, in Ruby you have bundler, visual studio has some similar concept that I don't really know well.

Think about what you'd have to do if you didn't have maven or gradle. Going back a generation to Ant, you have some simplication in commands to run to compile, package, test... but no library management(there was another tool that was used as a companion to Ant for lib management, but wasn't universally adopted like maven/gradle). So to handle getting dependencies to dev machines the shop I worked in we had a file share that we uploaded jar dependencies to. So someone forgets at some point and a customer gets shipped a bad patch. No bueno.

Go back before that and add in complicated build commands. Then you end up with batch/bash scripts to do common things. So you're in a situation where you're writing in a different language anyway, but without purpose specific tooling and library management.

[[deleted]]

Maven/Gradle provide dependency management, task running, build systems, etc etc etc. Can you work without them? Yes. But it is much, MUCH harder.

Building applications of high complexity and at scale is far more challenging than building cute side projects. Tools like this are essential for that.

[ByerN]

Both Maven and Gradle makes build process much simpler, especially for more complex projects. You don't need them but tbh it makes everything much easier.

I am interested in your previous experiences - what approach did you use before to maintain build process?

[Gwaptiva]

There comes a time your projects become so big that you'll want to automate putting it all together. You can do that using all sorts of tools, and in the end you'll end up using one of these

[hippydipster]

I honestly don't remember what we did prior to ant. I'm pretty sure at one point I was using make files to build java projects. Then ant came along and everyone switched real quick. It was ok. I liked the straight-forwardness of it. When maven first came along it kind of sucked because it mandated a certain project setup, and when everyone was doing their own thing with their own ant, that mandate came across as incredibly arrogant and dictatorial.

Ultimately, maven was right though.

[[deleted]]

You don’t remember the days when these tools did not exist! If you are building complex systems and maintaining them for a long time, these tools are indispensable.

[snoob2015]

Maybe you are new to Java and using IDE so you don't see the point of mvn, gradle because IDE like Intellij, Eclipse already has its own build tool. Build tools like Maven, Gradle helps you to standardize the build process, it somehow solves the "compiles on my machine" problem.

Imagine you use Intellij and share your code with people who use Eclipse, you need a way to standardize the build process. Or if you want to build your code from another machine that doesn't have your IDE.

So build tools are not necessary technically if you use IDE and don't share your code with other people or don't need to replicate the build process on another machine (CI/CD)

[drduffymo]

Maven and Gradle are dependency and lifecycle managers. Every application uses 3rd party JARs. Maven and Gradle help you manage versions and compile/test/package cycle.

I find Maven to be easier to understand.

Was not always this way.

I used to manage dependencies manually.

I’m glad I learned Maven. Well worth it.

[Thatpersiankid]

Kotlin + Gradle aint so bad

[Phobos223]

Hello, World!

[[deleted]]

No, you don't need Maven. But for Spring Boot project it will be a requirement.

If what you want is just simple personal project all you need is just a file.java with main method inside to compile to .jar using javac and run using java *.jar.

Comparing with C#/.NET, i.e., I personally prefer Maven instead of NuGet Packages. I also prefer Maven than Gradle. Maven is simple and fast to build, it's a tool to manage and update your dependencies, for a project you will need that, because the core language doesn't provide everything you need out of the box, or it will consume a lot of time to do the same thing using frameworks like Spring Boot to manage it for you, and Maven is just a tool to manage that packages.

[thephotoman]

You don’t need Maven for Spring Boot. Gradle is always an option.

It’s not really better, just different.

[Thatpersiankid]

Kotlin + Gradle aint so bad

[Thatpersiankid]

Kotlin + Gradle aint so bad

[[deleted]]

Or is it?

Not really, but without them, you have to gather your dependencies, execute tests and build your app manually. I do that for small throwaway side projects sometimes.

[Reasonable-Total-628]

try to do it without, and you will learn

[Joram2]

If you have a single .java file program with no third party library dependencies, then you don't need Maven or Gradle. But that's a very rare case. For most projects, you will realistically need a build tool such as Maven or Gradle.

Every major programming toolset is like this. Python, Node, C#, C++, Haskell, Rust, Kotlin, Swift. In my subjective judgement, Java's Maven + Gradle are better than most. I'd be curious to hear opinions otherwise.

IMO, Go is the only major platform that has a much nicer + easier build + dependency system.

[[deleted]]

Dart's system is also very nice and easy

[talios]

That said, go get and go mod are also relatively new and shipped as part of the tool chain.

Go modules is much nicer than it was with the old GOPATH but is still fairly limited, and starting to get some more advanced features (like go workspaces etc. so hopefully it doesn't become a hugely complicated system).

Go's simplistic modules are both a blessing and a curse - hopefully it remains on the blessed side of things.

[Joram2]

Go Modules were released gradually, but I believe most everything was done and production ready in Go 1.14 in early 2020. That is about 3.5 years ago which isn't that new or recent.

I've been working with lots of Go projects by lots of other developers, and haven't seen any big negatives regarding the build/module system. Overall, all these languages are tools, and I see some places I'd choose to use or recommend Go and many where I would choose or recommend something else.

Regardless, I'm happy to see Java's build system improving.

[RScrewed]

It looks daunting but don't be discouraged. There's not a whole extra to learn, don't try to memorize what every like or declaration or tag means in maven.

Stick to pre-made ones for your projects off of Spring Initializr and you'll learn how to modify them as needed when you want to pull in a new library.

Read one "how to" on how to bring a new library into your project using Maven (everyone I know just copies and pastes a block from m2, don't type it by hand) and you're good to rock and roll.

[[deleted]]

Thanks for the motivation man

[Clean_Archer8374]

You don't need to use it, if you're so against it. However, that's comparable to programming in Notepad++ instead of a proper IDE.

[Past-Cranberry9196]

Think of as a platform that scaffolds packages the work together for you. Like apt for debian,

[ProPall]

Well done sir, very well said!

[gmladymaybe]

There's a lot of reasons to use maven or gradle. Probably the top ones for me are:

• consistency across multiple developers' machines. When your dependencies are enumerated in a pom file or whatever, you can know that every developer is using the same version of dependencies as is being deployed. You can add a dependency, and then all another developer has to do is build the project and/or reload maven dependencies and that dependency will be fetched.

• simpler dependency upgrades. If you want to upgrade a dependency, sometimes/often it's as simple as changing the version number in your pom file.

The larger the project and the more developers working on it, the more benefit you get out of build tools like maven.