# ADR-0002 - Avoid using Java serialization

## Date

2012-12-01

## Context

In Gradle, we often need to serialize in-memory objects for caching or transmitting them across process barriers, etc.
Java serialization is one way to implement this, however, despite its simplicity of implementation, it has several drawbacks:

}

fun ProjectFeatures.buildReportTab(title: String, startPage: String) {
    feature {
        type = "ReportTab"
        param("startPage", startPage)
        param("title", title)
        param("type", "BuildReportTab")
    }
}

fun BaseGradleBuildType.gradleRunnerStep(
    model: CIBuildModel,
    gradleTasks: String,
    os: Os = Os.LINUX,
    extraParameters: String = "",
    daemon: Boolean = true,

 * of project dependencies. This optimizes module loading during runtime, as we will only load external
 * modules that are not loaded transitively by other project modules.
 *
 * We perform this filtering, since if we simply include all external dependencies, regardless of whether
 * they are already loaded transitively, there is a measurable performance impact during module-loading.
 */

                    val someVal: String = "some"
                    var someVar: String = "some"
                    fun foo(): String = "bar"
                }
            """,
            v2 = """
                class Source {
                    val someVal: String? = null
                    var someVar: String? = null
                    fun foo(): String? = null
                }
            """
        ) {

     */
    static boolean isBadFileInMergeCommit(String filePath, String mergeCommit, String masterCommit, String releaseCommit) {
        try {
            List<String> mergeCommitFileLines = showFileOnCommit(mergeCommit, filePath).readLines()
            List<String> masterCommitFileLines = showFileOnCommit(masterCommit, filePath).readLines()
            List<String> releaseCommitFileLines = showFileOnCommit(releaseCommit, filePath).readLines()

    private String rawCommentText;
    private final List<String> annotationNames = new ArrayList<String>();
    private String replacement;

    protected AbstractLanguageElement() {
    }

    protected AbstractLanguageElement(String rawCommentText) {
        this.rawCommentText = rawCommentText;
    }

    @Override
    public String getRawCommentText() {
        return rawCommentText;

abstract class BasePublishGradleDistribution(
    // The branch to be promoted
    val promotedBranch: String,
    val prepTask: String?,
    val triggerName: String,
    val gitUserName: String = "bot-teamcity",
    val gitUserEmail: String = "******@****.***",
    val extraParameters: String = "",
    vcsRootId: String = gradlePromotionMaster,
    cleanCheckout: Boolean = true
) : BasePromotionBuildType(vcsRootId, cleanCheckout) {

    )
}


fun Project.stringPropertyOrEmpty(projectPropertyName: String): String =
    stringPropertyOrNull(projectPropertyName) ?: ""


fun Project.stringPropertyOrNull(projectPropertyName: String): String? =
    gradleProperty(projectPropertyName).orNull


fun Project.selectStringProperties(vararg propertyNames: String): Map<String, String> =
    propertyNames.mapNotNull { propertyName ->

        List<Element> header = children(tr, "td");
        if (header.size() < 1) {
            throw new RuntimeException(String.format("Expected at least 1 <td> in <thead>/<tr>, found: %s", header));
        }
        Map<String, Element> inheritedValueTitleMapping = new HashMap<String, Element>();
        List<Element> valueTitles = new ArrayList<Element>();
        for (int i = 1; i < header.size(); i++) {

    private static final Pattern WHITESPACE_WITH_EOL = Pattern.compile("(?s)\\s+");
    private static final String START_HTML_COMMENT = "<!--";
    private static final String END_HTML_COMMENT = "-->";
    private static final Map<String, String> ENTITIES = new HashMap<String, String>();

    static {
        ENTITIES.put("amp", "&");
        ENTITIES.put("lt", "<");
        ENTITIES.put("gt", ">");