[
https://issues.apache.org/jira/browse/KAFKA-14524?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Ismael Juma updated KAFKA-14524:
--------------------------------
Description:
The `core` module has grown too large and it's time to split it into multiple
modules. The `core` module will be deleted once it's empty (a KIP will be
required for this).
Evidence of `core` growing too large is that it takes 1m10s to compile the main
code and tests and it takes hours to run all the tests sequentially.
As part of this effort, we should rewrite the Scala code in Java to reduce
developer friction, reduce compilation time and simplify deployment (i.e. we
can remove the scala version suffix from the module name). Scala may have a
number of advantages over Java 8 (minimum version in 3.x), Java 11 (minimum
version for clients in Kafka 4.x) and Java 17 (minimum version for non clients
in Kafka 4.x), but a mixture of Scala and Java (as we have now) is more complex
than just Java.
Another benefit is that code dependencies will be strictly enforced, which will
hopefully help ensure better abstractions.
This pattern was started with the `tools` (but not completed), `metadata` and
`raft` modules and we have (when this ticket was filed) a couple more in
progress: `group-coordinator` and `storage`.
This is an umbrella ticket and it will link to each ticket related to this goal.
was:
The `core` module has grown too large and it's time to split it into multiple
modules. The `core` module will be deleted once it's empty (a KIP will be
required for this).
Evidence of `core` growing too large is that it takes 1m10s to compile the main
code and tests and it takes hours to run all the tests sequentially.
As part of this effort, we should rewrite the Scala code in Java to reduce
developer friction, reduce compilation time and simplify deployment (i.e. we
can remove the scala version suffix from the module name). Scala may have a
number of advantages over Java 8 (minimum version we support now) and Java 11
(minimum version we will support in Kafka 4.0), but a mixture of Scala and Java
(as we have now) is more complex than just Java.
Another benefit is that code dependencies will be strictly enforced, which will
hopefully help ensure better abstractions.
This pattern was started with the `tools` (but not completed), `metadata` and
`raft` modules and we have (when this ticket was filed) a couple more in
progress: `group-coordinator` and `storage`.
This is an umbrella ticket and it will link to each ticket related to this goal.
> Modularize `core` monolith
> --------------------------
>
> Key: KAFKA-14524
> URL: https://issues.apache.org/jira/browse/KAFKA-14524
> Project: Kafka
> Issue Type: Improvement
> Reporter: Ismael Juma
> Priority: Major
>
> The `core` module has grown too large and it's time to split it into multiple
> modules. The `core` module will be deleted once it's empty (a KIP will be
> required for this).
> Evidence of `core` growing too large is that it takes 1m10s to compile the
> main code and tests and it takes hours to run all the tests sequentially.
> As part of this effort, we should rewrite the Scala code in Java to reduce
> developer friction, reduce compilation time and simplify deployment (i.e. we
> can remove the scala version suffix from the module name). Scala may have a
> number of advantages over Java 8 (minimum version in 3.x), Java 11 (minimum
> version for clients in Kafka 4.x) and Java 17 (minimum version for non
> clients in Kafka 4.x), but a mixture of Scala and Java (as we have now) is
> more complex than just Java.
> Another benefit is that code dependencies will be strictly enforced, which
> will hopefully help ensure better abstractions.
> This pattern was started with the `tools` (but not completed), `metadata` and
> `raft` modules and we have (when this ticket was filed) a couple more in
> progress: `group-coordinator` and `storage`.
> This is an umbrella ticket and it will link to each ticket related to this
> goal.
--
This message was sent by Atlassian Jira
(v8.20.10#820010)
