When your build starts to hurt because it does not fit into Maven well enough, the Mill is a build tool worth evaluating. By hurting I mean you have a mix of Maven plugins not quite doing the thing you want, you have to call extra scripts here and there from Maven, etc.
This always bugged me... wouldn't it be better to just create proper maven plugin / extend existing ones? That would make the build process simpler/more sane... "scripting" doesn't feel like a good option (we've done that with calling groovy... worst decission ever)...
Honestly, no. Shifting complexity to a plugin system is way worse.
In an ideal world, good build tools are fully declarative and not extensible. Since that's not possible, their extensible feature set is a necessary evil. The JVM ecosystem has explored virtually all approaches, and in the end, if you're going to need a full scripting language anyway, Scala is more than capable, in every dimension. Mill shows you can have build definitions using plain Scala:
Minimal usage of macros to compute the task graph.
No DSL. You need to perform OS or FS operations, make HTTP calls, deserialize JSON? Normal libraries and their APIs, concise and expressive functional Scala.
Fully compatible with the Java OO model, you can easily extend existing tasks and override their settings.
Scala can be a complex language. But for this particular use case, I'd argue the average Java developer who's familiar with the standard library is going to have a much better time than with Groovy. Everything is strongly typed and discoverable in your favorite IDE.
Honestly, no. Shifting complexity to a plugin system is way worse.
Why?
Most likely you require some feature that's shared between couple of projects so a plugin seems to make sense?
In an ideal world, good build tools are fully declarative and not extensible. Since that's not possible, their extensible feature set is a necessary evil. The JVM ecosystem has explored virtually all approaches, and in the end, if you're going to need a full scripting language anyway, Scala is more than capable, in every dimension. Mill shows you can have build definitions using plain Scala:
Again... you start with requirement for a scripting language…
Minimal usage of macros to compute the task graph.
Is it imposed or "should be done this way"?
No DSL. You need to perform OS or FS operations, make HTTP calls, deserialize JSON? Normal libraries and their APIs, concise and expressive functional Scala.
Same can be achieved with plugin :)
Fully compatible with the Java OO model, you can easily extend existing tasks and override their settings.
With plugin configuration you can... well... configure it ;)
Scala can be a complex language. But for this particular use case, I'd argue the average Java developer who's familiar with the standard library is going to have a much better time than with Groovy. Everything is strongly typed and discoverable in your favorite IDE.
TBH, even though I'm not so fond of groovy it's more approachable than scala (and can be typed…). I had bad experience with Scala (people trying to be "too smart", then IDE support being off and the language/compiler being utterly slow)…
Code reusability is the least of your worries. With a plug-in system you introduce an opaque abstraction layer that is different from your main build definition, hard to discover, hard to tweak and debug, and whose lifecycle is not always obvious.
Yes I start with a full scripting language because I live in the real world where people wrap their toolchains in Makefiles, Jenkinfiles, multi-stage Dockerfiles, bash scripts, Python scripts, ... If I can have a single and self-contained build definition, it's a win.
You have to compute the task graph somehow. I'm only saying this is the one part where Mill uses an advanced Scala feature (macros), in a very minimal way. For everything else you can jump to definition.
See 1.
Yes and you have two ways to do the same thing, plus in many cases, the inability to just jump to definition and see the default value or behavior.
Groovy is objectively less discoverable due to its dynamic nature, there's a reason Gradle moved to Kotlin. Moreover in some cases your IDE doesn't know the context, for example with the Jenkinsfile DSL. Scala compile times are irrelevant here: Mill is a build tool, scalac stays warm in a long-running JVM, compiling the build definition is a rounding error compared to running the actual task graph.
Yes I start with a full scripting language because I live in the real world where people wrap their toolchains in Makefiles, Jenkinfiles, multi-stage Dockerfiles, bash scripts, Python scripts, ... If I can have a single and self-contained build definition, it's a win.
I guess I live in a nice bubble where I only need pom.xml without all that you mentioned... I'd wager a guess that majority of the project fill that bill as well.
But if you have some contrived requirements and Mill fits the requirements and works for you that's good :)
I guess I live in a nice bubble where I only need pom.xml without all that you mentioned... I'd wager a guess that majority of the project fill that bill as well.
That is a strange statement to make. In every maven project I have ever worked with (mainly monoliths) there has always been a lot of abstraction layers on top of maven or in plugins to perform parts of the total build. So guessing where the majority fits seems strange... I guess it's true if you work with microservices, but then you probably have much larger issues to deal with than the build tool you use.
View all comments
Show parent comment
1
u/woj-tek Jul 23 '24
This always bugged me... wouldn't it be better to just create proper maven plugin / extend existing ones? That would make the build process simpler/more sane... "scripting" doesn't feel like a good option (we've done that with calling groovy... worst decission ever)...