Having worked on projects with fairly complex builds I have got the impression that most build systems are optimised for trivial scenarios and get very hacky when things get real. In the end we always end up with build.sh scripts that assemble several tools and perform tasks such as copying files etc. We often end up with CMake build that calls scripts and creates more build files to make the whole thing work. So, my question would be: why not have a build system for Java which is just a Java library and then the whole build process would be written in Java (or Scala)? Real™ languages are infinitely more expressive than build system DSLs and I find it that the default use case (just some dependencies, maybe build a doc) is actually quite rare. /rant
That's basically what Gradle is, with Groovy the current 'real' language (it's a dynamic scripting language) and Kotlin the next language (it's statically typed and like Scala).
Java is very verbose language and doesn't provide enough tools to write simple DSL. That's the main reason, IMO. People don't want their build scripts being very verbose. Though with Java 8 it might be better.
Please note that Maven written in Java and you can easily create your own plugin and use it from configuration. So you can do everything you want. The same applies for Gradle and probably every other Java build tool.
Also Gradle uses Groovy or Kotlin as a build script language. SBT uses Scala as a build script language. So it's similar to what you want.
The problem is that it is not default or recommended way of doing things. My issue is that yes, people do want the build script language to be simple, but this (in my experience) always comes to bite you when the project gets bigger.
I mostly work with CMake and there we have to do a lot of arcane gymnastics to do basic stuff like list manipulation or moving files around, simply because the language has most of these features tacked on after the creator realises that they are necessary.
In Gradle, for example, I have a fairly trivial library that needs to build some native bindings at the right moment and after fighting with the DSL I ended up writing the build script in PowerShell and just call that. I think that the build systems I have encountered so far focus on the 'simple' case too much and render even little more advanced tasks tedious.
I would be happier with a build system that does not declare any magic variables or default steps.
