Forem: E_Chronosands::

Some basic understanding of closure🎈

E_Chronosands:: — Tue, 12 May 2026 21:18:06 +0000

About closure

Quoting Wikipedia: In computer science, a closure, also known as a lexical closure or function closure, is a technique for implementing lexical binding in programming languages that support first-class functions. In implementation, a closure is a structure that stores a function (usually its entry address) and an associated environment (equivalent to a symbol lookup table).

The above description is very professional. I prefer to describe it this way: the ability of a function to remember and access variables in the scope in which it was defined. This characteristic is often used extensively in functional programming languages.

This type of code is typically written in JavaScript:

Why can the count variable still be accessed outside the outer function?
Because the outer function returns an inner function, and the inner function holds a reference to count, the local variable count will not be destroyed after outer finishes executing.

function outer() {
    let count = 0;

    return function inner() {
        count++;
        console.log(count);
    };
}

const fn = outer();

fn(); // 1
fn(); // 2

This demonstrates an important function of closures: they extend the lifespan of variables. When an inner function references an outer variable, that variable cannot be released and must be moved to the heap to survive.

Closure -> A function carries the context in which it was defined

Implementation of closures

A typical implementation involves defining a special data structure that stores the function address pointer and the lexical environment representation of the function at the time of closure creation (the binding of those non-local variables).

Because closures can generate references rather subtly, they are relatively difficult to implement in languages that do not have built-in garbage collection mechanisms.

The most common use of closures

Data privatization

Using closures prevents external code from directly modifying a variable.

function createCounter() {
    let count = 0;

    return {
        inc() {
            count++;
        },
        get() {
            return count;
        }
    };
}

const c = createCounter();

c.inc();
c.inc();

console.log(c.get());

Function Factory

function multiply(x) {
    return function(y) {
        return x * y;
    };
}

const double = multiply(2);

console.log(double(5));

React hooks

A simple implementation of useState:

let hooks = [];
let currentIndex = 0;

function useState(initialValue) {
    const index = currentIndex;

    hooks[index] = hooks[index] ?? initialValue;

    function setState(newValue) {
        hooks[index] = newValue;
        render();
    }

    currentIndex++;

    return [hooks[index], setState];
}

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, Scalability, Reliability, Adaptability

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 (Yes, it depends on the team's skill level. Don't ask me how I know 🙂)

In my opinion, the above comparison results only reflect some extreme scenarios. Both Maven and Gradle are constantly being optimized, and the performance difference is not significant in most scenarios.

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.