DEV Community: E_Chronosands::

Some differences between Gradle and Maven 🙌

E_Chronosands:: — Tue, 12 May 2026 16:23:39 +0000

About build tools

Gradle and Maven are two popular build tools. Build tools are software that automates the project build process. Such as compile code, download dependencies, run tests, package jar, release artifact ..., build tools encapsulate these reusable commands and processes into simpler commands, making project builds more standardized and consistent.

How is maven ?

Maven is a long-established and classic Java project build tool. Its core idea is convention over configuration.

According to the official Maven documentation:
We wanted a standard way to build the projects, a clear definition of what the project consisted of, an easy way to publish project information, and a way to share JARs across several projects.

Maven specifies that configuration files should be written in XML and specifies a standard directory structure.

├── src/main/java
├── src/test/java
├── pom.xml

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>6.0.0</version>
    </dependency>
</dependencies>

Therefore, its advantages are standardization, high readability, and ease of unifying enterprise standards.

A relatively complete configuration file looks like this:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>1.0.0</version>

    <properties>
        <maven.compiler.release>21</maven.compiler.release>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.1.0</version>
        </dependency>

    </dependencies>

</project>

How is gradle ?

The biggest feature of Gradle is its code-based build functionality. You can use groovy or kotlin to write the config file. Gradle makes the entire build process more flexible, allowing for features such as dynamically executing tasks and adding conditional builds.

According to the official Gradle documentation, Gradle has the following characteristics:

Comprehensibility
Expressive DSLs in Kotlin and Groovy make even the most complex build logic readable and maintainable.

Scalability
From solo projects to enterprise monorepos, build times stay proportional to change, not total project size.

Reliability
Reproducible outcomes, safe caching, dependable parallel execution, your build results should never be surprising.

Adaptability
A rich plugin ecosystem lets teams automate any scenario, from build to deployment, exactly the way they need.

dependencies {
    implementation("org.springframework:spring-core:6.0.0")
}

For complex, multi-module projects, Gradle allows for more granular build processes, enabling the addition of more monitoring tasks, etc.

def env = System.getenv("ENV")

if (env == "prod") {
    version = "1.0.0"
} else {
    version = "1.0.0-SNAPSHOT"
}

A relatively complete configuration file looks like this:

plugins {
    java
    id("org.springframework.boot") version "3.3.0"
    id("io.spring.dependency-management") version "1.1.5"
}

group = "com.example"
version = "1.0.0"

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(17))
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web")
    testImplementation("org.springframework.boot:spring-boot-starter-test")
}

Gradle and Maven

Comparison Item	Maven	Gradle
Configuration Style	XML	DSL / Groovy / Kotlin
Core Philosophy	Convention over Configuration	Programmable Build System
Flexibility	Relatively Low	High
Learning Curve	Relatively Low	High
Build Performance	Relatively Slower	Relatively Faster
Incremental Build Support	Basic	Strong
Caching Mechanism	Relatively Weak	Strong
Android Support	Limited	Official Standard
Usage in Traditional Enterprise Projects	Widely Used	Growing Adoption
Maintainability	Strong	Depends on Team Practices

Generally, Maven is suitable for systems that require stability and ease of maintenance and management. Gradle is better suited for Android, Kotlin, multi-module microservices, and large-scale projects.

Maven's configuration philosophy:
Restricting freedom in exchange for uniformity

Gradle's configuration philosophy:
Giving freedom in exchange for extensibility

Of course, the choice of such tools should primarily be based on the actual skill level of the personnel; there is no absolute good or bad.

Some basic understanding of event loop

E_Chronosands:: — Tue, 12 May 2026 15:31:06 +0000

The event loop is a core programming concept that coordinates task execution with asynchronous event handling. Widely found in: JavaScript, Node.js, Browser runtimes, Flutter, java, Game engines and some high-performance services such as Redis and Nginx.

The advantages of a normal synchronous design are linearity and simplicity, but the disadvantage is that the entire program execution can easily get stuck on some time-consuming operations.

console.log(1);

readSomeFiles(); // time-consuming operations

console.log(2);

the CPU spends most of its time waiting for I/O
threads are blocked
concurrency is poor

So, in order to better utilize the CPU and more rationally allocate timer tasks and simple ordinary tasks, the concept of the event loop was born.

Systems that use event loops typically operate like this (Think about how you usually write JavaScript code):

console.log(1);

setTimeout(() => console.log(2));

Promise.resolve().then(() => {
    console.log(3);
});

console.log(4);

Execute synchronous code.
Encounter asynchronous tasks (timers, network).
Hand over the asynchronous task to the system for processing.
The main thread continues execution.
After the asynchronous task is completed, add the callback to the queue.
Event Loop check: Is the call stack empty? If empty, retrieve the task from the queue and execute it.

In actual system implementation, complexity can arise due to the diversity of tasks. For example, JavaScript engines may divide tasks into macro tasks and micro tasks based on the actual use case in order to respond to various callbacks more effectively. (The meaning of micro tasks is to execute them as quickly as possible without interrupting the current code, A macro quest is a relatively complete task)

For a JavaScript engine:

Execute a macro task
Execute all micro tasks
Browser renders the UI
Begin the next round of the Event Loop

You can try the following code to understand event loop:

answer: 1 3 2 timeout

When a microtask is being executed, it will continue to execute as soon as a new microtask is discovered until the microtask queue is completely empty.

setTimeout(() => {
    console.log("timeout");
});

Promise.resolve().then(() => {
    console.log(1);

    Promise.resolve().then(() => {
        console.log(2);
    });
});

Promise.resolve().then(() => {
    console.log(3);
});

So, a classic question: Does setTimeout(fn, 0) really execute after 0ms? It does not execute after 0ms. In reality, it will be affected by factors such as the current task's duration, the number of microtasks, and the browser's minimum time slice.

Some basic understanding of function calls

E_Chronosands:: — Tue, 12 May 2026 14:23:56 +0000

Functions are a very important concept in program design. They can encapsulate relatively independent logic into a simple call, increasing the reusability of the logic. From a usage perspective, functions emphasize input and output; they accept parameters, perform a specific process, and then output the result.

A function is a type of subprogram, and it is also a type of callable unit. A programmer can write a function in source code that is compiled to machine code that implements similar semantics

Function calls are primarily accomplished using a stack data structure. In summary, It saves the current execution context by pushing onto the stack, then jumps to another piece of code to execute, and then pops the stack back to the previous context after execution is complete. And the structure used to save the current state is usually called a stack frame.

The structure used to save the current state is usually called a stack frame. From the perspective of high-level programming languages, it can be compared to a structure. However, in the underlying implementation using assembly language, it may simply use registers to record the top and bottom of the stack.

The CPU has no concept of functions, methods, classes, objects. The CPU only recognizes: instruction addresses, registers, memory, jumps, When you call an add function in a main function, for example:

int add(int a, int b) {
  // xxxx
}

int main() {
  add(1, 4);
  return 0;
}

The underlying assembly might look like this (x86–64):

"add(int, int)":
        push    rbp
        mov     rbp, rsp
        mov     DWORD PTR [rbp-4], edi
        mov     DWORD PTR [rbp-8], esi
        mov     edx, DWORD PTR [rbp-4]
        mov     eax, DWORD PTR [rbp-8]
        add     eax, edx
        pop     rbp
        ret
"main":
        push    rbp
        mov     rbp, rsp
        mov     esi, 5
        mov     edi, 1
        call    "add(int, int)"
        mov     eax, 0
        pop     rbp
        ret

The two crucial statements at the beginning of each function: push rbp and mov rbp, rsp, are used to create stack frames. (The purpose of push rbp is to restore the rbp register to its value before the call ends)

rbp and rsp are two commonly used register names.
rbp -> bottom of the current function stack
rsp -> top of the current stack

The call add(int, int) statement then performs two operations: saves the return address (next instruction address) and jumps to the new function to run:

And then it may also save some local variables and other information:

Next, some operations are performed using registers, and the results are saved to the eax register (this register is usually used to store the return value). Then, pop rbp restores the rbp register to its state before this function was called.

Finally, the ret statement corresponds to the call statement, and it also does two things: its function is to retrieve the return address from the top of the stack and jump back to main function. This concludes the call to the add function. Then execution will continue from the line mov eax, 0 in the main function.

Of course, please also note that the so-called popping of a stack frame may not actually clear old data for performance reasons; it may only change the state of registers.

Furthermore, with the advancement of modern compilers, many unnecessary steps are omitted, so the actual implementation may be even more streamlined and difficult to understand.

A more technical description of this process is that it involves temporarily transferring enforcement power and then restoring it.