Future of build-chain and source code

[mcpiroman]

DBeaver is an awesome project in terms of quality/open-sourceness/activity ratio. In order to keep the pace of development, I have some suggestions, but I want to know the attitude of maintainers and core contributors towards such changes. If I have a green light I may start to (and, if successful enough, finish) the required work, although some help would probably be, well, helpful :).

First of, I find the setup and working with build chain
(like adding dependencies) quite cumbersome, especially outside Eclipse IDE. I have not worked before with Eclipse-related stuff like the RCP, but I feel like it should be possible to streamline that. So I propose to either:

• Simply bump tycho - may somewhat help
• Migrate from tycho to some other build chain, like a Gradle-based https://github.com/diffplug/goomph . From a short investigation it could:
  • Simplify build configuration
  • Allow to work with IDEs supporting Gradle with no additional setup (most notably IntelliJ)
  • Allow to easily integrate dependencies, including Eclipse itself, from maven, and generally align the build chain to modern standards
• Do some further investigation in this regard

Secondly, I suggest to move from Java to other JVM language, most notably Kotlin. I know Java, I know how ubiques it is, and I still don't thrust it. Instead, Kotlin provides build in null-safety (no NPEs), reduction of builerplate (IMO can easily reduce code by half), better handling of mutability (e.g. Map vs MutableMap) and other features contributing to safetly and productivity. And it has full 2-way compatibility with Java.

In practice, this would implie a few things:

• Switching/twitching build system would become mandatory to support that
• Because AFAIK Kotlin's Eclipse plugin is still not very mature, IntelliJ may become the main IDE. I know it is already being used by some, but forcing it to others may be challenging.
• Even though Kotlin is very akin to Java and easy to learn by Java programmers (unlike say, Scala), some teaching will still need to be performed by the assumed majority of controbutors that don't speak it already

Fortunately most of such conversation can be made both automatically and gradually (Java and Kotlin files can sit next to each other) and I'm willing to take care, or at least investigate it (ofc. only the CE part).

What are your vision and plans in this regard?