<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: The concept of the JIT compiler originated from the need to improve the
    execution efficiency of programs. Early programs were often executed interpretively, which was
    usually slower. The JIT compiler emerged to enhance the run-time efficiency of programs.
  </p>
  <ul>
    <li>
      <strong>Before its emergence</strong>: Before the JIT compiler, programs typically needed to
      be fully compiled before execution or executed line-by-line through an interpreter, each
      method having its limitations.
    </li>
    <li>
      <strong>After its emergence</strong>: The introduction of the JIT compiler allowed programs to
      be compiled just in time during execution, combining the efficiency of pre-compilation with
      the flexibility of interpretive execution.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: A JIT compiler is a runtime compiler that compiles source code or
    bytecode into machine code on the fly to improve the execution efficiency of the program.
  </p>
  <ul>
    <li>
      <strong>Just-In-Time Compilation</strong>: Compiles blocks of code into machine code during
      program execution as needed.
    </li>
    <li>
      <strong>Performance Optimization</strong>: Enhances the speed and efficiency of program
      execution through optimized compiled code.
    </li>
    <li>
      <strong>Runtime Analysis</strong>: The JIT compiler can dynamically optimize based on the
      program's runtime behavior.
    </li>
  </ul>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li>
      <strong>Background</strong>: Java programs run on a virtual machine, and their code exists in
      bytecode form.
    </li>
    <li>
      <strong>Solution</strong>: The JIT compiler in the Java Virtual Machine compiles frequently
      executed bytecode into machine code, thus improving the execution speed of these codes.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: JIT compilation consumes certain computing resources, especially
    during the compilation process, which might slightly increase the program's startup time.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Modern JIT compilers are being optimized to reduce the
    resource consumption during compilation, improve compilation speed, and implement smarter code
    optimization strategies.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, JIT compilers may become more intelligent,
    able to more accurately predict which codes will be frequently executed, and achieve more
    efficient runtime optimization.
  </p>
</article>


Just-In-Time (JIT) Compiler

<article>
  <h2>2. Where Does It Come From?</h2>
  <p>
    <strong>Origin</strong>: Class loaders in Java are components used to load class files (‘.class’
    files) into the JVM (Java Virtual Machine). They were created to meet the need for dynamic
    loading and linking of class files.
  </p>
  <ul>
    <li>
      Before Appearance: Before class loaders, all classes had to be loaded and linked at once when
      a Java program started, which limited the flexibility and extensibility of Java programs.
    </li>
    <li>
      After Appearance: The introduction of class loaders enabled Java programs to load classes
      dynamically on demand, enhancing program modularity and flexibility.
    </li>
  </ul>

  <h2>2. What Is It?</h2>
  <hr />
  <p>
    <strong>Concept Explanation</strong>: Class loaders are responsible for reading Java bytecode
    and converting it into classes executable by the JVM. They load class files as needed, avoiding
    the overhead of loading all classes at once.
  </p>
  <p><strong>Three Important Principles</strong>:</p>
  <ol>
    <li>
      Delegation Model: By default, a class loader delegates the loading task to its parent loader
      and loads the class itself only if the parent loader fails.
    </li>
    <li>
      Visibility: A child loader can access classes loaded by its parent loader, but the parent
      loader cannot access classes loaded by the child loader.
    </li>
    <li>
      Uniqueness: The same class file, once loaded by the same class loader, exists as only one
      class instance in the JVM.
    </li>
  </ol>
  <p><strong>Real-World Example</strong>:</p>
  <ul>
    <li>Background: A large application needs to dynamically load plugins.</li>
    <li>
      Solution: The application uses custom class loaders to load different plugins, ensuring that
      the plugins do not interfere with each other and achieving high modularity.
    </li>
  </ul>

  <h2>3. Where Is It Going?</h2>
  <hr />
  <p>
    <strong>Limitations</strong>: The complexity of class loaders can lead to issues like class
    conflicts and memory leaks.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is optimizing class loader
    performance and security, such as faster loading speeds and better isolation.
  </p>
  <p>
    <strong>Future Development</strong>: Future developments may include more intelligent class
    loading strategies, like AI-based predictive loading, and improved class loading efficiency in
    cloud environments.
  </p>
</article>


ClassLoaders

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: The concepts of concurrency and multithreading originated from the need
    in computer science to improve the efficiency and responsiveness of programs. With the
    proliferation of multi-core processors, these concepts have been widely applied in Java.
  </p>
  <ul>
    <li>
      <strong>Before their emergence</strong>: Before the advent of multithreading and concurrency
      mechanisms, programs typically executed tasks sequentially in a single-threaded manner, unable
      to fully utilize the advantages of multi-core processors.
    </li>
    <li>
      <strong>After their emergence</strong>: With the introduction of concurrency and
      multithreading, Java programs can execute tasks simultaneously on multiple cores,
      significantly enhancing execution efficiency and responsiveness.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p><strong>Essence</strong>:</p>
  <ul>
    <li>
      <strong>Concurrency</strong>: Refers to multiple tasks being executed macroscopically at the
      same time, but they might alternate execution microscopically, not necessarily running
      simultaneously.
    </li>
    <li>
      <strong>Multithreading</strong>: A means of achieving concurrency, where multiple threads are
      created to run tasks on different execution paths.
    </li>
  </ul>
  <p><strong>Three Principles</strong>:</p>
  <ol>
    <li>
      <strong>Thread Safety</strong>: Ensuring that the access to shared data in a multi-threaded
      environment does not lead to inconsistencies or data corruption.
    </li>
    <li>
      <strong>Lock Mechanism</strong>: Using locks or other synchronization mechanisms to prevent
      multiple threads from accessing shared resources simultaneously.
    </li>
    <li>
      <strong>Resource Management</strong>: Efficiently managing thread resources, including their
      creation, use, and destruction.
    </li>
  </ol>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li>
      <strong>Background</strong>: Suppose you need to handle multiple concurrent user requests in a
      web server.
    </li>
    <li>
      <strong>Solution</strong>: Multithreading technology can be used to create a thread pool.
      Whenever there's a new user request, a thread from the pool is allocated to handle it, thereby
      improving response speed and processing efficiency.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: Multithreaded programming is complex and prone to errors,
    especially when it involves thread synchronization and shared data.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is moving towards developing
    more advanced concurrency control mechanisms, such as using concurrency frameworks and libraries
    (like Java's java.util.concurrent package) to simplify multithreaded programming.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, Java might further integrate smarter thread
    management and concurrency control technologies to increase efficiency and reduce programming
    complexity.
  </p>
</article>


Concurrency and Multithreading

<article>
  <h1>Java Memory Model (JMM)</h1>

  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: The Java Memory Model was designed to address concurrent errors caused
    by cache inconsistencies and instruction reordering in multithreaded programming. It is part of
    the Java Language Specification and has been a component of the Java Virtual Machine (JVM) since
    its inception.
  </p>
  <ul>
    <li>
      <strong>Before its emergence</strong>: Before the establishment of JMM, Java programs could
      exhibit different behaviors on different platforms due to inconsistencies in memory access.
    </li>
    <li>
      <strong>After its emergence</strong>: JMM provides a cross-platform consistency guarantee for
      memory access, allowing Java programs to run more stably across different platforms.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: The Java Memory Model defines the rules for accessing variables in
    shared memory and how threads interact with memory, ensuring the correctness and performance of
    multithreaded programs.
  </p>
  <ul>
    <li>
      <strong>Visibility</strong>: Ensures that modifications to shared variables by one thread are
      promptly visible to other threads.
    </li>
    <li>
      <strong>Atomicity</strong>: Guarantees the completeness of operations on variables, preventing
      partial updates in a multithreaded environment.
    </li>
    <li>
      <strong>Ordering</strong>: Prevents compilers and processors from reordering instructions,
      ensuring the sequentiality and predictability of program execution.
    </li>
  </ul>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li>
      <strong>Background</strong>: Suppose two threads are operating on a shared variable
      simultaneously.
    </li>
    <li>
      <strong>Solution</strong>: The JMM, through mechanisms like locks and the volatile keyword,
      ensures that changes to a variable by one thread are correctly seen by another, thus avoiding
      concurrent errors.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: Understanding and correctly applying the Java Memory Model can be
    relatively complex, requiring a deep understanding of concurrent programming.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is moving towards simplifying
    the complexity of concurrent programming and providing more straightforward and user-friendly
    concurrency tools.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, the Java Memory Model may be further
    optimized to provide more efficient concurrency control mechanisms, while also enhancing
    consistency and performance across different hardware platforms.
  </p>
</article>


Java Memory Model

Java 21

<article>
  <h2>1. Where Does It Come From?</h2>
  <hr />
  <p>
    <strong>Origin</strong>: The JVM was designed to realize Java's philosophy of "write once, run
    anywhere." It forms the core part of the Java platform, responsible for running Java bytecode.
  </p>
  <ul>
    <li>
      Before Appearance: Before the advent of the JVM, programs had to be compiled separately for
      each type of hardware and operating system.
    </li>
    <li>
      After Appearance: With the JVM, Java programs can run on any platform that has the JVM
      installed, freeing them from being limited to specific hardware and operating systems.
    </li>
  </ul>

  <h2>2. What Is It?</h2>
  <hr />
  <p>
    <strong>Concept Explanation</strong>: The JVM is a virtual machine that provides an environment
    to execute Java bytecode. It converts bytecode into machine code specific to each platform.
  </p>
  <p><strong>Three Important Components</strong>:</p>
  <ol>
    <li>Class Loader: Responsible for loading Java class files into memory.</li>
    <li>
      Runtime Data Area: Stores data during program execution, including the Heap, Stack, Method
      Area, Program Counter, etc.
    </li>
    <li>Execution Engine: Executes the Java bytecode stored in the method area.</li>
  </ol>
  <p><strong>Real-World Example</strong>:</p>
  <ul>
    <li>Background: Running a Java program.</li>
    <li>
      Using the JVM Process: The JVM first loads the required classes through the class loader, then
      allocates memory in the runtime data area, and finally, the execution engine starts executing
      the bytecode.
    </li>
  </ul>

  <h2>3. Where Is It Going?</h2>
  <hr />
  <p>
    <strong>Limitations</strong>: Although the JVM provides cross-platform capability, there is
    still room for improvement in performance and memory management.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is working on optimizing JVM
    performance, reducing memory usage, and improving garbage collection efficiency.
  </p>
  <p>
    <strong>Future Development</strong>: Future developments may include more efficient
    implementations of the JVM, or support for new hardware and technologies, such as optimizations
    for cloud computing and big data.
  </p>
</article>


JVM Architecture

JAVA

Abstraction

Object-oriented Programming

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: The concept of the Bean lifecycle is a core part of the Spring
    framework, originating from the need to manage Java objects (known as Beans) within the Spring
    container.
  </p>
  <ul>
    <li>
      <strong>Before its emergence</strong>: Before the advent of the Spring framework, the
      creation, initialization, and destruction of Java objects had to be manually managed by
      programmers.
    </li>
    <li>
      <strong>After its emergence</strong>: The emergence of Spring provided an automated way to
      manage the lifecycle of Java Beans, greatly simplifying object management.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: The Bean lifecycle in the Spring framework refers to the process a
    Bean undergoes from creation to destruction. During this process, a Bean goes through various
    stages, including instantiation, property setting, initialization, and destruction.
  </p>
  <ul>
    <li>
      <strong>Container Management</strong>: The entire lifecycle of a Bean is managed by the Spring
      container.
    </li>
    <li>
      <strong>Lifecycle Callbacks</strong>: Custom logic can be executed at different stages of the
      lifecycle by implementing specific interfaces or using annotations.
    </li>
    <li>
      <strong>Dependency Injection</strong>: The Spring container injects dependencies at
      appropriate stages in the Bean's lifecycle.
    </li>
  </ul>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li><strong>Background</strong>: Suppose there is a Bean for a database connection.</li>
    <li>
      <strong>Solution</strong>: In the Spring container, this database connection Bean would first
      be instantiated, then have its dependencies injected, followed by the execution of an
      initialization method, and finally, a destruction method when the container shuts down.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: Understanding and using the Bean lifecycle can be relatively
    complex, especially in scenarios involving multiple Beans with interdependencies.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is moving towards simplifying
    lifecycle management, providing more automation and annotation-driven lifecycle callbacks.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, the Spring framework may further enhance its
    capabilities in managing the Bean lifecycle, such as through more intelligent dependency
    injection and lifecycle callbacks to optimize application performance.
  </p>
</article>


Bean Lifecycle

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: The concept of Dependency Injection originates from the principle of
    "Inversion of Control" (IoC) in object-oriented programming. The Spring framework adopted this
    concept to alleviate the maintenance burden caused by hard-coded dependencies.
  </p>
  <ul>
    <li>
      <strong>Before its emergence</strong>: Prior to DI, dependencies in objects were typically
      created directly within the object via hardcoding, leading to high coupling and low
      reusability.
    </li>
    <li>
      <strong>After its emergence</strong>: The introduction of DI made managing dependency
      relationships more flexible, reducing coupling between components, and enhancing the
      testability and maintainability of the code.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: In the Spring framework, DI is a process that allows objects to define
    their dependencies, which are then provided through constructor parameters, factory method
    parameters, or properties of the object instance.
  </p>
  <ul>
    <li>
      <strong>Decoupling</strong>: DI helps objects to break away from hard-coded dependencies,
      increasing the independence of modules.
    </li>
    <li>
      <strong>Declarative Configuration</strong>: Dependencies can be declared in the Spring
      container via XML or annotations, without altering the class's own code.
    </li>
    <li>
      <strong>Container Management</strong>: Dependency relationships and object lifecycles are
      managed by the Spring container, simplifying the creation and management of objects.
    </li>
  </ul>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li>
      <strong>Background</strong>: Suppose there is a service class that requires a database
      connection.
    </li>
    <li>
      <strong>Solution</strong>: In the Spring framework, the database connection can be injected
      into the service class as a dependency through DI. This way, the service class does not need
      to know how to create the database connection and can focus on its core business logic.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: DI can lead to complex configurations, especially in large
    applications, where managing many dependencies can become challenging.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is moving towards simplifying
    configurations, enhancing the functionality of annotations, and automating dependency
    management.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, DI in Spring might continue to evolve
    towards more automation and intelligence, such as AI-assisted management and optimization of
    dependencies.
  </p>
</article>


Dependency Injection(DI)

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: Inversion of Control (IoC) as a software design principle aims to
    reduce the coupling between computer codes. The emergence of IoC containers in Java,
    particularly in modern frameworks like Spring, was intended to further implement this principle.
  </p>
  <ul>
    <li>
      <strong>Before its emergence</strong>: Before the advent of IoC containers, objects were
      typically created and managed directly in the code, leading to high coupling and difficulty in
      testing.
    </li>
    <li>
      <strong>After its emergence</strong>: The introduction of IoC containers changed the way
      objects are created and managed, allowing developers to focus more on business logic while
      improving code maintainability and scalability.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: An IoC container is a framework or library that manages the creation,
    configuration, and lifecycle of objects in a Java application. It manages objects by inverting
    control, meaning that the container takes over the creation and management of objects.
  </p>
  <ul>
    <li>
      <strong>Inversion of Control</strong>: Objects no longer create and manage dependencies
      themselves; instead, the container is responsible for this.
    </li>
    <li>
      <strong>Dependency Injection</strong>: The container provides the necessary dependencies to
      objects through Dependency Injection (DI).
    </li>
    <li>
      <strong>Declarative Management</strong>: The configuration of objects and their dependencies
      is usually declared through configuration files or annotations, without the need for hard
      coding in Java code.
    </li>
  </ul>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li>
      <strong>Background</strong>: Suppose there is a class in a Java application that requires
      multiple service components.
    </li>
    <li>
      <strong>Solution</strong>: With an IoC container, the class does not need to create and manage
      these service components itself. The container automatically injects the required components,
      allowing the class to focus on its business logic.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: Using an IoC container might lead to complex project structures
    and can be challenging for beginners to understand and master.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Currently, the industry is moving towards simplifying
    the configuration and use of IoC containers to improve their usability and flexibility.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, IoC containers may become more automated and
    intelligent, for instance, through more advanced dependency resolution and management mechanisms
    to enhance efficiency and reduce configuration errors.
  </p>
</article>


Inversion of Control (IoC) Container

Spring

Functional Programming

<article>
  <section>
    <h2>1. Where Does It Come From?</h2>
    <p>
      <strong>Origin</strong>: <strong>async/await</strong> is a programming paradigm first
      introduced in C# and .NET, later adopted by JavaScript and other languages. It was created to
      simplify asynchronous programming, making asynchronous code easier to write and read.
    </p>
    <p>
      <strong>State Change</strong>: Before <strong>async/await</strong>, asynchronous programming
      relied on callbacks and events, leading to "callback hell". With <strong>async/await</strong>,
      asynchronous code structure became clearer and more synchronous in style.
    </p>
  </section>

  <section>
    <h2>2. What Is It?</h2>
    <p>
      <strong>Definition</strong>: <strong>async/await</strong> allows developers to write
      asynchronous code in a more synchronous manner. The <strong>async</strong> keyword declares a
      function as asynchronous, while <strong>await</strong> waits for an asynchronous operation to
      complete.
    </p>
    <p><strong>Three Key Principles</strong>:</p>
    <ul>
      <li>
        <strong>Asynchronous Function Declaration</strong>: Functions declared with
        <strong>async</strong> return a Promise.
      </li>
      <li>
        <strong>Awaiting Promise Resolution</strong>: <strong>await</strong> is used inside
        <strong>async</strong> functions to wait for Promise resolution.
      </li>
      <li>
        <strong>Error Handling</strong>: Use <strong>try/catch</strong> to handle errors in
        asynchronous operations.
      </li>
    </ul>
    <p><strong>Practical Example</strong>:</p>
    <p><em>Background</em>: Fetching data from the internet, an asynchronous operation.</p>
    <p>
      <em>Solution</em>: Use <strong>async/await</strong> in a function to await data fetching
      completion.
    </p>
    <pre>
            <code class="language-javascript">
async function fetchData() {
    try {
        let response = await fetch('https://api.example.com/data');
        let data = await response.json();
        console.log(data);
    } catch (error) {
        console.error('Fetching data failed', error);
    }
}
            </code>
        </pre>
  </section>

  <section>
    <h2>3. Where Is It Going?</h2>
    <p>
      <strong>Limitations</strong>: <strong>async/await</strong> applies only to Promise-based
      operations and not suitable for non-Promise async operations.
    </p>
    <p>
      <strong>Optimization Direction</strong>: The industry is exploring better error handling and
      integration of asynchronous flow control tools, like functional programming with
      <strong>async/await</strong>.
    </p>
    <p>
      <strong>Future Development</strong>: Potential for more language features and tools to
      simplify asynchronous programming, improving concurrent processing and integration into
      various programming environments.
    </p>
  </section>
</article>


<article>
  <h2>1. Where Does It Come From?</h2>
  <p>
    <strong>Origin and Background</strong>: The concept of the Call Stack originates from the
    "stack" data structure in computer science. In programming and computer memory management, a
    stack is used to record the sequence of function calls during program execution.
  </p>
  <p>
    <strong>Comparative State</strong>: Before the widespread understanding of the call stack, the
    mechanism of function calling and returning in programs was harder to track and manage. The
    introduction of the call stack provided a clear and orderly way to manage program execution.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    <strong>Essential Explanation</strong>: In programming languages like JavaScript, the call stack
    is a stack structure that records the calls and execution of functions. When a function is
    called, it is added to the top of the stack; when the function returns, it is removed from the
    top of the stack.
  </p>
  <p><strong>Key Principles</strong>:</p>
  <ol>
    <li>
      <strong>Last In, First Out</strong>: The stack follows the "Last In, First Out" (LIFO)
      principle, where the last function pushed onto the stack is the first to complete execution
      and be popped off.
    </li>
    <li>
      <strong>Limited Size</strong>: The size of the call stack is limited, and exceeding its
      capacity can lead to a "stack overflow" error.
    </li>
    <li>
      <strong>Record of Function Execution</strong>: Each function call has its context and
      execution state, all of which are recorded in the stack.
    </li>
  </ol>
  <p><strong>Real-World Example</strong>:</p>
  <pre><code class="language-javascript">
        function firstFunction() {
            secondFunction();
            console.log('Executing first function');
        }

        function secondFunction() {
            console.log('Executing second function');
        }

        firstFunction();
        // Outputs: "Executing second function"
        // Then outputs: "Executing first function"
    </code></pre>

  <h2>3. Where Is It Going?</h2>
  <p>
    <strong>Limitations</strong>: The size limit of the call stack means that deeply nested or
    infinitely recursive function calls can lead to stack overflow errors.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Developers need to optimize recursive logic, avoid
    deeply nested calls, or use techniques like tail call optimization to reduce stack usage.
  </p>
  <p>
    <strong>Future Developments</strong>: With the evolution of programming languages and runtime
    environments, the management and optimization of the call stack may become more efficient, for
    example, through improved error handling and debugging tools to better manage and visualize the
    call stack.
  </p>
</article>


<article>
  <h2>1. What?</h2>
  <p>
    <strong>Origin</strong>: Callback hell originates from the use of callback functions in
    asynchronous programming, especially in environments like Node.js.
  </p>
  <p>
    <strong>Comparative State</strong>: Before callback hell became a recognized issue, asynchronous
    operations were handled primarily with callbacks. After the recognition of callback hell,
    alternative approaches like Promises and async/await were developed.
  </p>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: Callback hell refers to a situation where callbacks are nested within
    other callbacks several levels deep.
  </p>
  <ul>
    <li>
      <strong>Nested Structure</strong>: The deeper the nesting, the more complex the callback hell.
    </li>
    <li><strong>Error Handling</strong>: Managing errors in callback hell can be challenging.</li>
    <li>
      <strong>Readability and Maintenance</strong>: Deeply nested callbacks reduce code readability
      and maintainability.
    </li>
  </ul>
  <p><strong>Real-world Example</strong>:</p>
  <p>Background: Performing multiple asynchronous file operations in Node.js.</p>
  <p>
    Application: Reading a file, then writing to another file, each step nested in the previous
    callback.
  </p>
  <pre>
    <code class="language-javascript">
    fs.readFile('file1.txt', function(err, data) {
      if (err) throw err;
      fs.writeFile('file2.txt', data, function(err) {
        if (err) throw err;
        console.log('File written successfully');
      });
    });
    </code>
    </pre>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: The main limitation of callback hell is its impact on code
    quality.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Developers have shifted towards using Promises and
    async/await.
  </p>
  <p>
    <strong>Future Direction</strong>: The trend is to avoid callback hell through better practices
    and newer features like async/await.
  </p>
</article>


<article>
  <h2>1. Why we need control flow?</h2>
  <p>
    Control structures are fundamental components in programming languages used to control the flow
    of code execution. They originated from early programming language designs, aiming to provide
    more flexible and effective code execution paths.
  </p>
  <p>
    Before the appearance of JavaScript and other programming languages, program execution was
    typically linear. The introduction of these control structures allowed programmers to execute
    code based on conditions or repeat certain code, making programs more dynamic and flexible.
  </p>

  <h2>2. What is it?</h2>
  <p>JavaScript control structures mainly include:</p>
  <ul>
    <li>
      Conditional statements: <b>if</b> and <b>else</b>, used for executing code blocks based on
      specific conditions.
    </li>
    <li>
      Selection statements: <b>switch</b>, used for executing different code blocks under multiple
      conditions.
    </li>
    <li>
      Loop statements: <b>for</b>, <b>while</b>, and <b>do-while</b>, used for repeatedly executing
      code blocks until a condition is no longer true.
    </li>
    <li>
      Jump statements: <b>break</b> and <b>continue</b>, used for exiting loops early or skipping
      the current loop iteration.
    </li>
  </ul>
  <p>Three principles for applying these control structures:</p>
  <ol>
    <li>
      Choose the appropriate control structure based on the actual situation to simplify code logic
      and improve efficiency.
    </li>
    <li>Be cautious to avoid infinite loops and overly complex conditionals.</li>
    <li>
      Use <b>break</b> and <b>continue</b> judiciously to control the loop flow, enhancing code
      readability and efficiency.
    </li>
  </ol>
  <p>Practical example:</p>
  <p>Background: Assign grades based on user-entered scores.</p>
  <p>Application: Use <b>if-else</b> and <b>switch</b> to handle different score ranges.</p>
  <p>Code example:</p>
  <pre><code class="language-javascript">
&lt;script&gt;
let score = 85;
if (score &gt;= 90) {
console.log("Excellent");
} else if (score &gt;= 75) {
console.log("Good");
} else {
console.log("Pass");
}

switch (true) {
case score &gt;= 90:
    console.log("Excellent");
    break;
case score &gt;= 75:
    console.log("Good");
    break;
default:
    console.log("Pass");
}
&lt;/script&gt;
</code></pre>

  <h2>3. Where is it going?</h2>
  <p>
    Limitations: Overuse or improper use of control structures can make code difficult to understand
    and maintain.
  </p>
  <p>
    Current optimization direction: In modern JavaScript development, it's recommended to use more
    concise and expressive control structures, such as arrow functions and Promise structures.
  </p>
  <p>
    Possible future developments: New control structures may emerge to adapt to more complex
    programming patterns and demands, like further advancements in asynchronous programming and
    functional programming.
  </p>
</article>


Control Flow

<article>
    <div>1. Why we need data type?</div>
    <p>
      The concept of data types in JavaScript originates from the need to categorize data in
      programming languages. It was developed to better manage and use data during programming.
    </p>
    <p>
      Before the advent of JavaScript, other programming languages like C or Java already had their
      own data type systems. The emergence of JavaScript provided a set of data types more suited
      for web pages and web applications.
    </p>
  </div>

  <div>
    <div>2. What is it?</div>
    <p>
      JavaScript data types are mainly divided into two categories: primitive types and object
      types.
    </p>
    <ul>
      <li>
        Primitive types include: String, Number, Boolean, Undefined, Null, Symbol (added in ES6),
        BigInt (large integer, added in ES2020).
      </li>
      <li>Object types are a composite type, including: Object, Array, Function, etc.</li>
    </ul>
    <p>Three principles for applying these data types:</p>
    <ol>
      <li>Choose the appropriate type for efficient data handling.</li>
      <li>Avoid unnecessary type conversions to reduce errors and improve performance.</li>
      <li>Understand the mechanisms of conversion and comparison between types.</li>
    </ol>
    <p>Practical example:</p>
    <ul>
      <li>Background: Collecting age information from users in a web form.</li>
      <li>
        Application: The user's age input (a string) needs to be converted to a number type for
        comparison or calculation.
      </li>
      <li>
        Code example:
        <pre><code class="language-javascript">
&lt;script&gt;
let ageString = "30"; // User-entered age, string type
let ageNumber = Number(ageString); // Convert to number type
if (ageNumber &gt;= 18) {
console.log("Adult");
}
&lt;/script&gt;</code></pre>
      </li>
    </ul>
  </div>
  <div class="section">
    <div class="section-title">3. Where is it going?</div>
    <p>
      Limitations: Certain JavaScript data types (like global variables) may lead to memory leaks.
      Additionally, type conversions can cause unexpected errors.
    </p>
    <p>
      Current optimization direction: Enhancing the strictness and consistency of the type system,
      as seen with the introduction of TypeScript.
    </p>
    <p>
      Future development: There might be the addition of new data types or optimization of existing
      types' memory and performance to suit more complex application scenarios.
    </p>
</article>


Data Types

<article>
  <h2>1. Where Does It Come From?</h2>
  <p>
    <strong>Origin and Background</strong>: The concept of the Event Loop originated from early
    computer system designs, but it has found a particular application in JavaScript. JavaScript is
    a single-threaded language, and in web browsers and Node.js environments, the event loop
    mechanism enables asynchronous programming.
  </p>
  <p>
    <strong>Comparative State</strong>: Before the event loop, programs typically executed in a
    blocking manner, leading to inefficiency. With the event loop, JavaScript can remain responsive
    while executing long-running tasks, improving performance and user experience.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    <strong>Essential Explanation</strong>: The event loop is a part of the JavaScript runtime
    environment, responsible for coordinating code execution, event handling, and message
    processing. It continually checks if the call stack is empty and, if so, takes the next message
    from the queue (e.g., from setTimeout, user interactions) and executes it.
  </p>
  <p><strong>Key Principles</strong>:</p>
  <ol>
    <li>
      <strong>Non-blocking</strong>: The event loop allows JavaScript to perform asynchronous
      operations without blocking the main thread.
    </li>
    <li>
      <strong>Order Guarantee</strong>: The event loop ensures that events in the message queue are
      processed in order.
    </li>
    <li>
      <strong>Coordinated Handling</strong>: It works in conjunction with the call stack and message
      queue to keep the program running smoothly.
    </li>
  </ol>

  <h2>3. Where Is It Going?</h2>
  <p>
    <strong>Limitations</strong>: The event loop model can lead to complex asynchronous coding
    patterns, which are hard to debug and maintain.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Modern JavaScript frameworks and tools (like
    Async/Await, Promises) provide more intuitive and concise ways to handle asynchronous
    operations, making interactions with the event loop more user-friendly.
  </p>
  <p>
    <strong>Future Developments</strong>: With the advent of new programming models and language
    features, the concept of the event loop might become further abstracted, offering developers
    more efficient and manageable tools for asynchronous programming.
  </p>
</article>


<article>
  <section>
    <h2>1. Why we need functions?</h2>
    <p>
      It allows programmers to encapsulate code for specific operations. This concept was borrowed
      from earlier programming languages, particularly influenced by Scheme and Java. Without
      functions, code repetition and complexity were common issues and with functions, code became
      more modular, reusable, and maintainable
    </p>
  </section>

  <section>
    <h2>2. What Are They?</h2>
    <p>
      Functions in JavaScript are objects that encapsulate executable code. They can take
      parameters, perform operations, and return values.
    </p>
    <h3>Different Types of Functions</h3>
    <ul>
      <li>Regular Functions: Defined with the <strong>function</strong> keyword.</li>
      <li>Anonymous Functions: Nameless functions, often used as callbacks.</li>
      <li>Arrow Functions (ES6): Use <strong>=&gt;</strong> for a concise syntax.</li>
      <li>Generator Functions (ES6): Can be paused and resumed with <strong>yield</strong>.</li>
    </ul>
    <pre><code class="language-javascript">document.getElementById('myButton').addEventListener('click', () => {
    console.log('Button clicked!');
});
            </code></pre>
  </section>

  <section>
    <h2>3. Where Are They Going?</h2>
    <ul>
      <li>
        <b>Limitations and Optimization:</b> Overuse or improper use of functions in JavaScript,
        especially in the global scope, can lead to performance issues and hard-to-track errors.
      </li>
      <li>
        <b>Future Development:</b> As JavaScript continues to evolve, the concept of functions is
        expanding, for example, with the introduction of arrow functions and generator functions,
        offering new possibilities for writing more efficient and concise code. Additionally,
        functional programming is becoming increasingly popular in JavaScript, emphasizing
        immutability and the use of higher-order functions.
      </li>
    </ul>
  </section>
</article>


functions

<article>
  <h2>1. Where Does It Come From?</h2>
  <p>
    <strong>Origin and Background</strong>: JavaScript operators originated with the JavaScript
    language itself, designed to facilitate data manipulation and logical expression. JavaScript was
    created in 1995 by Brendan Eich of Netscape to enhance web page interactivity.
  </p>
  <p>
    <strong>Comparative State</strong>: Before the advent of JavaScript, web page interactivity was
    limited, relying mainly on server-side processing. The introduction of JavaScript and its
    operators allowed for more complex data processing and decision-making on the client side,
    greatly enhancing the dynamism and interactivity of web pages.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    <strong>Essential Explanation</strong>: JavaScript operators are used to perform mathematical
    operations, comparison operations, logical operations, etc. These include arithmetic operators
    (like +, -), comparison operators (like ==, >), logical operators (like &&, ||), and other
    special operators (like the conditional (ternary) operator ? :).
  </p>
  <p><strong>Key Principles</strong>:</p>
  <ol>
    <li>
      <strong>Accuracy</strong>: Ensure the correct use of operators to achieve the intended
      results.
    </li>
    <li>
      <strong>Priority</strong>: Understand the precedence among different operators to correctly
      parse expressions.
    </li>
    <li>
      <strong>Handling Edge Cases</strong>: Especially in comparison and logical operations, be
      mindful of null values, undefined values, and other special cases.
    </li>
  </ol>
  <p><strong>Real-World Example</strong>:</p>
  <ul>
    <li>Background: Need to decide an action based on the comparison of two values.</li>
    <li>
      Solution: Use the comparison operator &gt; to determine the size, then use the conditional
      operator to choose the corresponding action.
    </li>
    <li>Sample Code:</li>
  </ul>
  <pre>
    <code class="language-javascript">
        &lt;script&gt;
            let a = 10, b = 20;
            let result = (a &gt; b) ? "a is greater" : "b is greater";
            console.log(result);  // Outputs "b is greater"
        &lt;/script&gt;
    </code>
    </pre>

  <h2>3. Where Is It Going?</h2>
  <p>
    <strong>Limitations</strong>: JavaScript operators are limited by the performance and
    application scope of the JavaScript language itself.
  </p>
  <p>
    <strong>Optimization Direction</strong>: In modern JavaScript development, there is a greater
    focus on combining operators with asynchronous programming and functional programming, such as
    Promises, async/await, etc.
  </p>
  <p>
    <strong>Future Development</strong>: With the evolution of technologies like WebAssembly,
    JavaScript and its operators may increasingly integrate with other language features and
    performance optimizations. Additionally, as the ECMAScript standard continues to evolve, new
    operators and functionalities may be introduced.
  </p>
</article>


<article>
  <h2>1. Why we need it?</h2>
  <p>
    Promises are an important concept in JavaScript for asynchronous programming. They were
    introduced to address issues associated with traditional callback functions, such as callback
    hell.
  </p>
  <p>
    Before the introduction of Promises, asynchronous programming in JavaScript heavily relied on
    callback functions. As applications became more complex, managing nested callbacks became
    increasingly difficult. The introduction of Promises provided a clearer and more powerful way to
    handle asynchronous operations.
  </p>

  <h2>2. What is it?</h2>
  <p>
    A Promise is an object that represents the eventual completion or failure of an asynchronous
    operation.
  </p>
  <p>It has three states: pending, fulfilled, and rejected.</p>
  <p>
    A Promise object allows you to associate handlers with the success value or the reason for
    failure.
  </p>
  <p>Three principles for using Promises:</p>
  <ol>
    <li>Prefer using Promises over traditional callback functions for asynchronous operations.</li>
    <li>
      Handle the success and failure of asynchronous operations by chaining
      <strong>.then()</strong> and <strong>.catch()</strong>.
    </li>
    <li>
      Use <strong>async</strong> and <strong>await</strong> syntax (introduced in ES2017) to make
      asynchronous code look more like synchronous code.
    </li>
  </ol>
  <p>Practical example:</p>
  <p>Background: Fetching and processing data from the internet.</p>
  <p>Application: Using Promises to manage the asynchronous nature of network requests.</p>
  <p>Code example:</p>
  <pre><code class="language-javascript">
fetch('https://example.com/data')
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
    </code></pre>

  <h2>3. Where is it going?</h2>
  <p>
    Limitations: Although Promises solve the problem of callback hell, they can still lead to
    complex chained calls when handling multiple asynchronous operations.
  </p>
  <p>
    Current optimization direction: Combining <strong>async</strong> and <strong>await</strong> to
    simplify the usage of Promises, making asynchronous code more intuitive and maintainable.
  </p>
  <p>
    Possible future development: As JavaScript and web development continue to evolve, more
    efficient and powerful patterns and tools for handling asynchronous operations may emerge.
  </p>
</article>


<article>
  <h1>Understanding the Spread Operator in JavaScript</h1>

  <section>
    <h2>1. Where does it come from?</h2>
    <p>The spread operator is a JavaScript syntax feature introduced in ES6 (ECMAScript 2015).</p>
    <ul>
      <li>
        <strong>Origin</strong>: It was designed to simplify the manipulation of arrays and objects,
        especially in copying, merging, or extending them.
      </li>
      <li>
        <strong>Comparison</strong>: Before ES6, merging arrays or objects typically required
        functions like <code>concat</code>, or loops. The spread operator offers a more concise way
        to perform these operations.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      The spread operator (<code>...</code>) allows an expression to be expanded into multiple
      elements (in arrays) or multiple properties (in objects).
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: It makes copying and merging arrays or objects simpler
        and more intuitive.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>
            Use the spread operator when copying arrays or objects to avoid directly modifying the
            original data.
          </li>
          <li>
            Use it when needing to merge elements/properties of arrays or objects into a new array
            or object.
          </li>
          <li>It can be used in function calls to pass array elements as arguments.</li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Suppose you need to merge two arrays or merge the properties of one object into another.
      </dd>
      <dt>Application</dt>
      <dd>Use the spread operator to simplify this process.</dd>
      <dt>Code Example</dt>
      <dd>
        <pre><code>
// Merging arrays
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let mergedArr = [...arr1, ...arr2]; // [1, 2, 3, 4, 5, 6]

// Merging objects
let obj1 = { a: 1, b: 2 };
let obj2 = { c: 3, d: 4 };
let mergedObj = { ...obj1, ...obj2 }; // { a: 1, b: 2, c: 3, d: 4 }
                </code></pre>
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: The spread operator can only perform shallow copies; for
        deeply nested objects, it cannot copy the references of inner nested objects.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: When dealing with deeply nested objects,
        consider using other methods like <code>JSON.parse(JSON.stringify(object))</code> for deep
        copying.
      </li>
      <li>
        <strong>Future Development</strong>: The use of the spread operator might become more
        widespread as the JavaScript language evolves, especially in handling immutable data,
        functional programming, and similar scenarios.
      </li>
    </ul>
  </section>
</article>


Spread Operator(ES6)

<article>
  <h2>1. Where Does It Come From?</h2>
  <p>
    <strong>Origin and Background</strong>: The <strong>this</strong> keyword exists in many
    object-oriented programming languages, but its behavior in JavaScript is quite unique. Initially
    designed as a simple client-side scripting language, JavaScript has evolved into a powerful,
    feature-rich language, with <strong>this</strong> playing a crucial role in this evolution.
  </p>
  <p>
    <strong>Comparative State</strong>: Before JavaScript, web page interactions were relatively
    simple. With the introduction of JavaScript, the <strong>this</strong> keyword became a way to
    reference dynamic context, allowing functions and methods to be reused in different contexts.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    <strong>Essential Explanation</strong>: In JavaScript, <strong>this</strong> typically refers to
    the context object that the function is being called upon. Its value depends on how the function
    is called, not how it's defined.
  </p>
  <p><strong>Key Principles</strong>:</p>
  <ol>
    <li>
      <strong>Context-Dependent</strong>: The value of <strong>this</strong> is usually determined
      when the function is called, not when it's defined.
    </li>
    <li>
      <strong>Strict Mode Differences</strong>: In strict mode ('use strict'), the value of
      <strong>this</strong> in global functions is <strong>undefined</strong>, whereas in non-strict
      mode, it is the global object.
    </li>
    <li>
      <strong>Arrow Function Characteristics</strong>: In arrow functions, <strong>this</strong> is
      lexically bound to the context where it is defined.
    </li>
  </ol>
  <p><strong>Real-World Example</strong>:</p>
  <pre>
      <code class="language-javascript">
          const person = {
              name: 'Alice',
              greet: function() {
                  console.log('Hello, my name is ' + this.name);
              }
          };
          person.greet();  // Outputs "Hello, my name is Alice"
      </code>
      </pre>

  <h2>3. Where Is It Going?</h2>
  <p>
    <strong>Limitations</strong>: The dynamic nature of <strong>this</strong> can sometimes lead to
    confusion, especially in callback functions and closures.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Modern JavaScript frameworks and libraries (like React)
    offer clearer and more concise ways to handle <strong>this</strong>, such as using arrow
    functions to avoid common pitfalls of <strong>this</strong>.
  </p>
  <p>
    <strong>Future Developments</strong>: As the ECMAScript standard continues to evolve, the
    understanding and use of <strong>this</strong> may become more intuitive and consistent.
  </p>
</article>


<article>
  <section>
    <h2>1. Why do we need variable declarations (var,let,const) ?</h2>
    <p>
      <strong>variable declarations: </strong> Was designed to store data values in a program and
      allow these values to be used in different parts of the program, without it data management in
      programs was more complex, requiring manual management of data storage and retrieval in
      memory.
    </p>
    <p>
      <strong>var:</strong> var was introduced in the early versions of JavaScript for variable
      declaration.
    </p>
    <p>
      <strong>let and const:</strong> let and const were introduced in ES6 (ECMAScript 2015) to
      address some issues with var, such as hoisting and scope confusion.
    </p>
  </section>

  <section>
    <h2>2. What the difference?</h2>
    <h3>var</h3>
    <ul>
      <li><strong>Scope:</strong> Function scope.</li>
      <li>
        <strong>Hoisting:</strong> Variable declarations are hoisted to the top of the function or
        global scope.
      </li>
      <li><strong>Reassignable:</strong> Yes.</li>
    </ul>

    <h3>let</h3>
    <ul>
      <li><strong>Scope:</strong> Block scope (e.g., within {}).</li>
      <li><strong>Hoisting:</strong> Does not hoist.</li>
      <li><strong>Reassignable:</strong> Yes.</li>
    </ul>

    <h3>const</h3>
    <ul>
      <li><strong>Scope:</strong> Block scope.</li>
      <li><strong>Hoisting:</strong> Does not hoist.</li>
      <li><strong>Reassignable:</strong> No, it declares a constant.</li>
    </ul>

    <h4>Real-World Example</h4>
    <p>Declaring a variable in a loop, needing to reassign it in each iteration.</p>
    <pre><code class="language-javascript">
for (var i = 0; i < 5; i++) {
    // Using var, i is accessible outside the loop
}

for (let j = 0; j < 5; j++) {
    // Using let, j is only valid within this loop block
}

const k = 5;
// Using const, the value of k cannot change
            </code></pre>
  </section>

  <section>
    <h2>3. Where Are They Going?</h2>
    <p>
      <strong>Limitations:</strong>
      var: Can lead to scope-related errors. let and const: Relatively stricter, requiring clearer
      scope management.
    </p>
    <p>
      <strong>Optimization Direction:</strong>
      Gradually decrease the use of var in favor of let and const for safer, more predictable code
      behavior.
    </p>
    <p>
      <strong>Future Development:</strong>
      The JavaScript community and standards are leaning towards more use of let and const to
      promote maintainability and readability of code.
    </p>
  </section>
</article>


  Variable Declarations( var let const )

<article>
  <section>
      <h2>1. Why do we need Web Components?</h2>
      <p><strong>Origin:</strong> The concept of Web Components originated from the need for encapsulation and reuse in web development.</p>
      <p>Before Web Components, developers relied on specific frameworks or libraries for component creation, leading to non-standardized and technology stack dependent solutions.</p>
  </section>
  <section>
      <h2>2. What Are They?</h2>
      <p><strong>Essence:</strong> Web Components are a set of browser-native technologies allowing the creation of reusable custom elements.</p>
      <ul>
          <li><strong>Custom Elements:</strong> Define custom elements and behavior.</li>
          <li><strong>Shadow DOM:</strong> Encapsulate markup and style.</li>
          <li><strong>HTML Templates:</strong> `<template>` and `<slot>` tags for non-rendered markup on page load.</li>
      </ul>

      <h3>Key Principles</h3>
      <ul>
          <li>Encapsulation through Shadow DOM.</li>
          <li>Reusability of custom elements.</li>
          <li>Independence from specific frameworks or libraries.</li>
      </ul>

      <h3>Real-World Example</h3>
      <pre><code class="language-javascript">&lt;template id="user-card-template"&gt;
&lt;style&gt;
  /* Encapsulated styles */
&lt;/style&gt;
&lt;div class="user-card"&gt;
  &lt;slot name="name"&gt;&lt;/slot&gt;
  
&lt;/div&gt;
&lt;/template&gt;
      </code></pre>
  </section>
  <section>
      <h2>3. Where Are They Going?</h2>
      <p>Web Components may become a standard in building complex web applications, with ongoing enhancements and broader browser support.</p>
  </section>
</article>

Accessibility

<article>
  <h1>Compound Components</h1>

  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: Compound Components is a design pattern commonly used in front-end
    development, especially with modern JavaScript libraries and frameworks like React. It emerged
    to address the issues of state management and reusability in User Interface (UI) components.
  </p>
  <ul>
    <li>
      <strong>Before its emergence</strong>: Prior to compound components, developers typically
      managed interactions between components by passing callbacks and state, which could lead to
      complex and hard-to-maintain code structures.
    </li>
    <li>
      <strong>After its emergence</strong>: With the introduction of compound components, developers
      could manage relationships and states between components more concisely, enhancing code
      readability and maintainability.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    <strong>Essence</strong>: The compound component pattern allows you to decompose a component
    into several closely related subcomponents, each responsible for rendering a part of the
    interface, while still collectively forming a unified component.
  </p>
  <ul>
    <li>
      <strong>Modularity</strong>: Each subcomponent is independent and can be used alone or in
      combination with other components.
    </li>
    <li>
      <strong>Reusability</strong>: Subcomponents are designed to ensure sufficient flexibility and
      reusability.
    </li>
    <li>
      <strong>State Management</strong>: The parent component usually manages the state, and the
      subcomponents receive the state and callbacks through props.
    </li>
  </ul>
  <p><strong>Case Explanation</strong>:</p>
  <ol>
    <li>
      <strong>Background</strong>: Suppose you need to create a customizable tab component in a web
      application.
    </li>
    <li>
      <strong>Solution</strong>: You can create a compound component that includes a parent
      component (TabContainer) managing the state, and child components (TabItem) representing each
      tab. This way, you can reuse the TabItem component in different places, with all state
      management handled by the TabContainer.
    </li>
  </ol>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: Compound components can lead to overly complex component
    structures, especially in large projects, and may be difficult to understand for beginners.
  </p>
  <p>
    <strong>Optimization Direction</strong>: The current industry trend is to simplify the API
    design of compound components to improve their readability and usability.
  </p>
  <p>
    <strong>Future Development</strong>: In the future, compound components might be integrated with
    more front-end development technologies (like micro-frontends) to further enhance component
    maintainability and scalability.
  </p>
</article>


<article>
  <section>
    <h2>1. Where does it come from?</h2>
    <p>
      The Context API is a feature of React designed to solve the problem of data transmission in
      the component tree.
    </p>
    <ul>
      <li>
        <strong>Origin</strong>: In the early versions of React, passing data across multiple layers
        of components required prop drilling, which was cumbersome and inefficient in complex
        component trees.
      </li>
      <li>
        <strong>Comparison</strong>: Before the Context API, React applications often relied on
        additional state management libraries (like Redux) to manage cross-component states. The
        introduction of the Context API allows for internal state management within React in less
        complex scenarios without using these libraries.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      The Context API allows developers to share values across components without having to
      explicitly pass props through every level of the component tree.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: It works by creating a Context object, which can be
        accessed at any point in the tree.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>Avoid overusing Context; it should not be used for passing all states.</li>
          <li>Maintain the independence and reusability of components when using it.</li>
          <li>Consider using Context when multiple components need to access the same data.</li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Suppose there is a theme switching feature that needs to share theme settings across
        multiple components.
      </dd>
      <dt>Application</dt>
      <dd>
        Use the Context API to create a theme Context, which can be accessed and modified in any
        child component.
      </dd>
      <dt>Code Example</dt>
      <dd>
        <pre><code>
const ThemeContext = React.createContext('light');

class App extends React.Component {
    render() {
        return (
            &lt;ThemeContext.Provider value="dark"&gt;
                &lt;Toolbar /&gt;
            &lt;/ThemeContext.Provider&gt;
        );
    }
}

function Toolbar(props) {
    return (
        &lt;div&gt;
            &lt;ThemedButton /&gt;
        &lt;/div&gt;
    );
}

class ThemedButton extends React.Component {
    static contextType = ThemeContext;
    render() {
        return &lt;Button theme={this.context} /&gt;;
    }
}
                </code></pre>
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: The Context API is not suitable for data that updates
        frequently, as it may lead to performance issues.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Combine the use of the Context API with other
        state management methods (like Hooks) to improve performance and code maintainability.
      </li>
      <li>
        <strong>Future Development</strong>: Future versions of React may further optimize the
        performance of the Context API and add more related features and improvements.
      </li>
    </ul>
  </section>
</article>


Context API

Controlled vs Uncontrolled Components

Error Boundaries

<article>
  <section>
    <h2>1. Where does it come from?</h2>
    <p>
      React Fragments were introduced in React version 16 as a feature to solve specific rendering
      issues.
    </p>
    <ul>
      <li>
        <strong>Origin</strong>: Before this, React components had to return a single root element.
        This limitation hindered certain layout implementations and could lead to unnecessary DOM
        elements.
      </li>
      <li>
        <strong>Comparison</strong>: Before the introduction of Fragments, developers often used
        extra <code>&lt;div&gt;</code> or other elements to wrap component content, even when these
        elements were not always necessary in the DOM.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      React Fragments allow components to return multiple elements without the need for an
      additional DOM element to wrap them.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: Fragments act like an invisible container that can hold
        multiple child elements but do not produce extra markup in the DOM structure.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>
            Use Fragments when you need to return multiple elements without adding extra DOM nodes.
          </li>
          <li>
            Declare Fragments using <code>&lt;React.Fragment&gt;</code> or its shorthand form
            <code>&lt;&gt;</code>.
          </li>
          <li>
            Fragments are particularly useful in components like tables and lists that require
            specific structures.
          </li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Suppose you need to return multiple <code>&lt;li&gt;</code> elements in a component, but do
        not want them wrapped in an additional <code>&lt;div&gt;</code> or other elements.
      </dd>
      <dt>Application</dt>
      <dd>Use Fragments to directly return these <code>&lt;li&gt;</code> elements.</dd>
      <dt>Code Example</dt>
      <dd>
        <pre><code>
function ListItem() {
    return (
        &lt;React.Fragment&gt;
            &lt;li&gt;Item 1&lt;/li&gt;
            &lt;li&gt;Item 2&lt;/li&gt;
        &lt;/React.Fragment&gt;
    );
}
                </code></pre>
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: Fragments are invisible and cannot be used as containers with
        accessible attributes, nor can they receive styles.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Continue exploring different component design
        patterns to optimize component structure and reduce unnecessary DOM nodes.
      </li>
      <li>
        <strong>Future Development</strong>: As the React ecosystem continues to evolve, the use of
        Fragments might become more widespread, helping developers to handle components and DOM
        structures more flexibly.
      </li>
    </ul>
  </section>
</article>


Fragments

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    Higher Order Components (HOC) are an advanced technique in the React framework for reusing
    component logic.
  </p>
  <ul>
    <li>
      <strong>Origin</strong>: They originate from the concept of higher-order functions in
      functional programming. At the early stages of React's development, as component logic became
      complex, there was a need for a pattern to share this logic.
    </li>
    <li>
      <strong>Comparison</strong>: Before the advent of HOCs, reusing logic in React components was
      commonly done through mixins. With the introduction of HOCs, logic reuse became clearer and
      more modular.
    </li>
  </ul>

  <h2>2. What is it?</h2>
  <p>
    A Higher Order Component is essentially a function that takes a component and returns a new
    component.
  </p>
  <ul>
    <li>
      <strong>Method of Solution</strong>: HOCs enhance or inject additional props into the original
      component by wrapping and composing it.
    </li>
    <li>
      <strong>Three Key Principles</strong>:
      <ol>
        <li>Do not modify the original component within the HOC, instead, use composition.</li>
        <li>Pass through unrelated props.</li>
        <li>Maximize composability.</li>
      </ol>
    </li>
  </ul>
  <p><strong>Example</strong>:</p>
  <dl>
    <dt>Background</dt>
    <dd>
      Suppose there is a text input component that needs data validation and logging functionality.
    </dd>
    <dt>Application</dt>
    <dd>
      Create an HOC that adds validation and logging functionality to the original component, then
      use this HOC to enhance the text input component.
    </dd>
    <dt>Code Example</dt>
    <dd>
      <pre><code>
    function withLogging(WrappedComponent) {
        return function(props) {
            // Logging logic
            console.log('Logging...');
            // Return the enhanced component
            return &lt;WrappedComponent {...props} /&gt;;
        };
    }
            </code></pre>
    </dd>
  </dl>

  <h2>3. Where is it going?</h2>
  <ul>
    <li>
      <strong>Limitations</strong>: HOCs can lead to prop name conflicts and potentially increase
      the complexity of the component tree.
    </li>
    <li>
      <strong>Direction for Optimization</strong>: Use new React features like Hooks to simplify
      shared logic and reduce dependency on HOCs.
    </li>
    <li>
      <strong>Future Development</strong>: In future versions of React, Hooks and other functional
      programming techniques might replace some use cases of HOCs.
    </li>
  </ul>
</body>


High Order Components

<article>
  <section>
    <h2>1. Where does it come from?</h2>
    <p>
      Hooks are a new feature introduced in React version 16.8, allowing the use of state and other
      React features in functional components.
    </p>
    <ul>
      <li>
        <strong>Origin</strong>: Before Hooks, React's functional components couldn't use state and
        lifecycle features, which were only available in class components. The introduction of Hooks
        removed this limitation.
      </li>
      <li>
        <strong>Comparison</strong>: Before Hooks, React developers had to choose between functional
        and class components. With Hooks, functional components gained abilities similar to class
        components, like state management and lifecycle control.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      Hooks are a set of functions that allow developers to "hook into" React state and lifecycle
      features within functional components.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: They offer a more concise and intuitive way to manage
        state and side effects without writing class components.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>
            Only use Hooks at the top level, not inside loops, conditions, or nested functions.
          </li>
          <li>
            Only call Hooks from React functions, avoid calling them from regular JavaScript
            functions.
          </li>
          <li>
            When using Hooks for component features, focus on separation of concerns rather than
            lifecycle methods.
          </li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Suppose you need to build a component that displays a counter, which can be incremented and
        decremented.
      </dd>
      <dt>Application</dt>
      <dd>
        Use the `useState` Hook to manage the counter's state, and the `useEffect` Hook to handle
        side effects after the component updates.
      </dd>
      <dt>Code Example</dt>
      <dd>
        <pre><code>
    function Counter() {
        const [count, setCount] = useState(0);
    
        useEffect(() => {
            document.title = `You clicked ${count} times`;
        });
    
        return (
            &lt;div&gt;
                &lt;p&gt;You clicked {count} times&lt;/p&gt;
                &lt;button onClick={() => setCount(count + 1)}&gt;Click me&lt;/button&gt;
            &lt;/div&gt;
        );
    }
                    </code></pre>
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: For complex state logic, Hooks may not be as intuitive as
        class components, especially in large projects.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Continue to develop and improve the Hooks API
        for easier management of complex states and side effects.
      </li>
      <li>
        <strong>Future Development</strong>: We may see more specialized Hooks in the future,
        providing more custom functionality and optimizations to meet different development needs.
      </li>
    </ul>
  </section>
</article>


Hooks

<article>
  <h1>Understanding Lazy Loading in React</h1>

  <section>
    <h2>1. Where does it come from?</h2>
    <p>
      Lazy loading is a technique to optimize web page or application load performance, which has
      been incorporated into React to enhance app efficiency.
    </p>
    <ul>
      <li>
        <strong>Origin</strong>: Traditionally, web applications loaded all resources at once,
        leading to long initial load times, especially in large applications.
      </li>
      <li>
        <strong>Comparison</strong>: Before lazy loading was introduced in React, applications
        typically loaded all components, regardless of whether they were immediately needed. With
        lazy loading, components are loaded only when needed, reducing initial load time.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      In React, lazy loading refers to loading components on demand, i.e., they are loaded only when
      they need to be rendered.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: Implemented using React’s
        <code>React.lazy</code> function and <code>Suspense</code> component.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>Prioritize lazy loading for large components and those that change frequently.</li>
          <li>
            Provide appropriate loading indicators when using lazy loading to enhance user
            experience.
          </li>
          <li>Pay attention to the granularity of code splitting to avoid excessive loading.</li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Imagine a large application where certain components are only needed for specific routes or
        after certain user interactions.
      </dd>
      <dt>Application</dt>
      <dd>Use lazy loading for these components, loading them only when truly needed.</dd>
      <dt>Code Example</dt>
      <dd>
        <pre><code>
import React, { Suspense } from 'react';
const LazyComponent = React.lazy(() => import('./LazyComponent'));

function App() {
    return (
        &lt;Suspense fallback={&lt;div&gt;Loading...&lt;/div&gt;}&gt;
            &lt;LazyComponent /&gt;
        &lt;/Suspense&gt;
    );
}
                </code></pre>
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: Lazy loading might cause some parts of the application to have
        a slight delay after the initial load.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Combine preloading strategies and smarter
        resource management to further enhance user experience.
      </li>
      <li>
        <strong>Future Development</strong>: As web applications continue to evolve, lazy loading
        techniques might become more intelligent and automated, better balancing load performance
        and user experience.
      </li>
    </ul>
  </section>
</article>


Lazy Loading

Props

<article>
  <section>
    <h2>1. Where does it come from?</h2>
    <p>
      State is a core concept in React applications, used to control the behavior and rendering of
      components.
    </p>
    <ul>
      <li>
        <strong>Origin</strong>: React's design philosophy is reactive and declarative, where the
        concept of state provides a dynamic data source for components.
      </li>
      <li>
        <strong>Comparison</strong>: Before React, traditional JavaScript DOM manipulation was
        mostly imperative, involving direct DOM manipulation to change the interface. React
        introduced the concept of state as a more efficient way to control interface updates.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      In React, the state is an object that stores data affecting the rendering and behavior of a
      component.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: State allows components to update themselves based on
        changes in user interaction or other factors.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>State should be as simple as possible to avoid unnecessary complexity.</li>
          <li>
            State updates may be asynchronous, so new state should not rely on the current state
            value.
          </li>
          <li>
            State should be limited to data that affects rendering, avoiding storing unrelated data
            in the state.
          </li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Suppose there is a numeric counter component that needs to display and update a number
        count.
      </dd>
      <dt>Application</dt>
      <dd>
        Use state to store the count value, and update the state to increase the count when a button
        is clicked.
      </dd>
      <dt>Code Example</dt>
      <dd>
        <pre><code>
class Counter extends React.Component {
    constructor(props) {
        super(props);
        this.state = { count: 0 };
    }

    incrementCount = () => {
        this.setState(prevState => ({
            count: prevState.count + 1
        }));
    };

    render() {
        return (
            &lt;div&gt;
                &lt;p&gt;{this.state.count}&lt;/p&gt;
                &lt;button onClick={this.incrementCount}&gt;Increment&lt;/button&gt;
            &lt;/div&gt;
        );
    }
}
                </code></pre>
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: Improper management of state can lead to components being
        difficult to maintain, especially in large projects.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Use state management libraries (like Redux,
        MobX) or the Context API for better state sharing between components.
      </li>
      <li>
        <strong>Future Development</strong>: Future versions of React may introduce more tools and
        methods to simplify state management, enhancing the performance and maintainability of
        applications.
      </li>
    </ul>
  </section>
</article>


State

Suspense

React

<article>
  <section>
    <h2>What is Fibers?</h2>
    <p>
      A Fiber is an instance of a component in React, representing a unit of work in the UI. Fibers
      restructure the rendering process into a linked list, optimizing resource allocation and
      rendering performance.
    </p>
  </section>

  <section>
    <h2>Origin and Purpose</h2>
    <ul>
      <li>
        <strong>Background</strong>: React's initial rendering process, before Fibers, was based on
        a recursive call stack, which had limitations in handling intensive UI updates and
        animations.
      </li>
      <li>
        <strong>Why Fibers?</strong>: Introduced to enhance React's ability to handle complex UIs
        and improve performance for applications with heavy rendering tasks.
      </li>
    </ul>
  </section>
  <section>
    <h2>Key Features and Principles</h2>
    <ol>
      <li>
        <strong>Incremental Rendering</strong>: Fibers allow React to split rendering work into
        chunks and spread it out over multiple frames.
      </li>
      <li>
        <strong>Prioritization of Tasks</strong>: Enables prioritizing updates based on importance,
        improving responsiveness.
      </li>
      <li>
        <strong>Concurrency</strong>: Allows pausing, resuming, or aborting rendering tasks,
        enhancing efficiency.
      </li>
    </ol>
  </section>

  <section>
    <h2>Impact and Use</h2>
    <p>
      Fibers contribute to smoother, more responsive user interfaces and maintain a familiar API for
      React developers.
    </p>
  </section>

  <section>
    <h2>Future Directions</h2>
    <p>
      Lays the foundation for future improvements in React, like Concurrent Mode, further enhancing
      rendering and update handling.
    </p>
  </section>
</article>


Fibers

<article>
  <section>
    <h2>1. Where does it come from?</h2>
    <p>Reconciliation is a core process in React used for efficiently updating the UI.</p>
    <ul>
      <li>
        <strong>Origin</strong>: As React applications became increasingly complex, there was a need
        for an efficient way to determine which parts of the UI needed to be updated to optimize
        performance.
      </li>
      <li>
        <strong>Comparison</strong>: Before the reconciliation process, updating the UI might have
        required re-rendering the entire component tree, even if there were only minor changes.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      Reconciliation is the process used by React to compare differences between the new and old
      virtual DOM trees, and determine the minimal updates needed in the actual DOM.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: When the state of a component changes, React creates a
        new virtual DOM tree and compares it with the tree from the last render.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>Update only the elements that have differences, rather than the entire tree.</li>
          <li>Use efficient algorithms to minimize the necessary computations.</li>
          <li>Reuse existing elements as much as possible, instead of creating new ones.</li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>Imagine a list component in which some items' data have changed.</dd>
      <dt>Application</dt>
      <dd>
        React uses the reconciliation algorithm to identify the changed parts and updates only those
        parts of the DOM, rather than the entire list.
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: While the reconciliation algorithm is efficient, it's not
        perfect. In some cases, it may not identify all the optimal paths for updates.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Continuously improve the reconciliation
        algorithm to better identify and handle various update scenarios.
      </li>
      <li>
        <strong>Future Development</strong>: The React team and community may continue to explore
        new algorithms and strategies to further enhance the performance and accuracy of the
        reconciliation process.
      </li>
    </ul>
  </section>
</article>


Reconciliation

<article>
  <section>
    <h2>1. Where does it come from?</h2>
    <p>
      The Virtual DOM is a core concept in the React framework, developed to enhance the performance
      and efficiency of applications.
    </p>
    <ul>
      <li>
        <strong>Origin</strong>: The concept of the Virtual DOM was proposed by the React developer
        team to solve the problem of efficiently updating the view.
      </li>
      <li>
        <strong>Comparison</strong>: Before the Virtual DOM, most JavaScript frameworks and
        libraries operated directly on the actual DOM, which often resulted in inefficient
        performance during large-scale updates.
      </li>
    </ul>
  </section>

  <section>
    <h2>2. What is it?</h2>
    <p>
      The Virtual DOM is a lightweight JavaScript object, representing a version of the DOM in
      memory.
    </p>
    <ul>
      <li>
        <strong>Method of Solution</strong>: By simulating DOM operations in memory instead of
        directly on the actual DOM, React minimizes the number of real DOM manipulations, thereby
        enhancing performance.
      </li>
      <li>
        <strong>Three Key Principles</strong>:
        <ol>
          <li>
            The Virtual DOM allows React to calculate the most efficient method of updating the DOM
            beforehand, in memory.
          </li>
          <li>
            React updates the actual DOM only when necessary, reducing unnecessary DOM
            manipulations.
          </li>
          <li>
            Using the Virtual DOM can increase the responsiveness and overall performance of
            applications.
          </li>
        </ol>
      </li>
    </ul>
    <p><strong>Example</strong>:</p>
    <dl>
      <dt>Background</dt>
      <dd>
        Imagine an application with frequent UI updates, such as a dynamic interactive interface.
      </dd>
      <dt>Application</dt>
      <dd>
        With the Virtual DOM, React can quickly calculate the minimal range of updates and
        efficiently update the UI without redrawing the entire interface.
      </dd>
    </dl>
  </section>

  <section>
    <h2>3. Where is it going?</h2>
    <ul>
      <li>
        <strong>Limitations</strong>: While the Virtual DOM improves performance, it also introduces
        additional computational and memory overhead.
      </li>
      <li>
        <strong>Direction for Optimization</strong>: Further optimize the Virtual DOM algorithm to
        reduce computational overhead and memory usage.
      </li>
      <li>
        <strong>Future Development</strong>: Future developments may focus on making the Virtual DOM
        even more efficient and implementing similar concepts in other frameworks and libraries.
      </li>
    </ul>
  </section>
</article>


Virtual Dom

React Core

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>TypeScript</strong> was born to provide a type system and support for ES6+ on top of
    JavaScript. Before TypeScript's emergence, JavaScript, as a dynamically typed language, was
    highly flexible but prone to type errors in large projects. TypeScript’s introduction allowed
    developers to detect potential type errors during coding.
  </p>

  <h2>2. What is it?</h2>
  <p>
    <strong>TypeScript</strong> is a superset of JavaScript, adding a type system and compile-time
    type checking. The three key principles of TypeScript include:
  </p>
  <ul>
    <li><strong>Type Annotation:</strong> Allowing developers to specify the type of variables.</li>
    <li><strong>Interfaces:</strong> Defining the structure of objects.</li>
    <li><strong>Classes and Modules:</strong> Supporting the latest ES6+ features.</li>
  </ul>
  <p>
    A simple example: In JavaScript, you might accidentally add a string to a number. Using
    TypeScript, you can specify types for variables, like <code>let num: number = 5;</code> and
    <code>let str: string = "hello";</code>. This way, when you try <code>num + str</code>,
    TypeScript will prompt an error at compile time.
  </p>

  <h2>3. Where is it going?</h2>
  <p>
    The main limitation of <strong>TypeScript</strong> is that it adds to the learning curve and
    development time. Currently, the industry is optimizing towards improving compiler performance
    and enhancing support for modern JavaScript features. In the future, TypeScript may continue to
    deepen its integration with the JavaScript ecosystem, providing more intelligent type inference
    and more efficient compilation strategies.
  </p>
</article>


Basic Types

Conditional Types

Function Overloading

<article>
  <h2>1. Where Does It Come From?</h2>
  <p>
    Generics originate from type systems in computer science, particularly in object-oriented and
    functional programming. Prior to generics, programming data structures and functions could
    typically handle only specific data types. The introduction of generics enabled flexible
    handling of various data types while maintaining type safety.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    Generics allow for the definition of classes, interfaces, or methods without specifying the
    exact types of data they operate on. Key principles in using generics include:
  </p>
  <ul>
    <li>Type Safety: Checking types at compile time rather than runtime.</li>
    <li>Code Reusability: Enabling the same code to be used across different data types.</li>
    <li>Flexibility: Enhancing code flexibility to be applicable for various data types.</li>
  </ul>
  <p>
    Example: For creating an array to store any data type, you can define a generic array class like
    <code>Array&lt;T&gt;</code>, where <code>T</code> can be any type. This allows creation of
    arrays like <code>Array&lt;number&gt;</code> or <code>Array&lt;string&gt;</code> to store
    different data types.
  </p>

  <h2>3. Where Is It Going?</h2>
  <p>
    The main limitation of generics is the potential increase in code complexity for understanding
    and maintenance. Many programming languages are now developing smarter generic inference
    mechanisms to simplify generic code creation and understanding. In the future, generics might
    integrate with advanced programming paradigms, like metaprogramming and dependent types,
    enhancing code flexibility and expressiveness.
  </p>
</article>


Generics

<article>
  <h2>1. Where Does It Come From?</h2>
  <p>
    Tuples originate from mathematics and computer science, designed to store elements with a fixed
    count and possibly varying types. Before tuples, programming languages had data structures with
    either homogeneous types (like arrays) or variable element counts (like lists). Tuples
    introduced a data structure that is both fixed in number and diverse in type.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    A tuple is a data structure that holds a fixed number of elements, with each element potentially
    being of a different type. Key principles of tuples include:
  </p>
  <ul>
    <li>
      Fixed Number of Elements: The count of elements in a tuple is unchangeable once defined.
    </li>
    <li>Type Diversity: Elements in a tuple can be of different data types.</li>
    <li>Order: The order of elements in a tuple is fixed, accessed by index.</li>
  </ul>
  <p>
    Example: In a programming scenario requiring storing a point's x-coordinate (a number) and a
    label (a string), a tuple like <code>(3.5, "Point A")</code> can be used, where
    <code>3.5</code> is numerical, and <code>"Point A"</code> is a string, ensuring clarity and
    type-safety.
  </p>

  <h2>3. Where Is It Going?</h2>
  <p>
    The limitations of tuples are their unsuitability for storing many elements or for scenarios
    requiring frequent element modifications. Presently, some languages are enhancing type checking
    and performance for tuples. In the future, tuples may gain broader support in more languages and
    integrate more closely with modern programming concepts like destructuring assignment.
  </p>
</article>


Tuples

Type guards

Type Inference

<div>
  <h2>1. Where Does It Come From?</h2>
  <p>
    Union types originate from the type systems in programming, particularly in type theory and
    functional programming. Before union types, programming languages often limited variables and
    function parameters to a single type. The introduction of union types brought flexibility and
    expressiveness by allowing variables to represent multiple possible types.
  </p>

  <h2>2. What Is It?</h2>
  <p>
    Union types are a variable type that can store one of several different types, such as an
    integer or a string. Key principles of using union types include:
  </p>
  <ul>
    <li>Type Diversity: Union types can encompass two or more different types.</li>
    <li>Type Safety: Operations must be safe for all possible types in a union type variable.</li>
    <li>Clarity: Specify the current type as clearly as possible when using union types.</li>
  </ul>
  <p>
    Example: In scenarios like writing a function that accepts either a number or a string, a union
    type such as <code>number | string</code> can be used, enhancing the function's flexibility for
    multiple input types.
  </p>

  <h2>3. Where Is It Going?</h2>
  <p>
    The limitation of union types is in their potential to increase code complexity due to the need
    to handle multiple types. Currently, many programming languages and type systems are developing
    smarter type inference mechanisms to ease the use of union types. In the future, integration
    with advanced type systems, like dependent types, might occur, enhancing expressiveness and
    safety.
  </p>
</div>


Union and Intersection types

Typescript

Bisect

Blame

Cherry Pick

Fetch

Git Flow

Large File System

Pull

Reset

Revert

Stash

SubModules

Trunk Based Development

Git Object Model

Index (Staging Area)

Storage Mechanism

Git Core

Backlog

Daily Standup

Product owner

Retro

Scrum Master

Sprint

Sprint Planning

Story Points

SCRUM/AGILE

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin and Purpose</strong>: The Content Security Policy (CSP) is a browser feature
    designed to enhance web security. Its main purpose is to prevent cross-site scripting (XSS)
    attacks and other code injection attacks. CSP achieves this by specifying trusted sources of
    content.
  </p>
  <p>
    <strong>State Comparison</strong>: Before the introduction of CSP, websites primarily relied on
    server-side security measures to prevent attacks. The introduction of CSP enabled browsers to
    participate in security protection, providing an additional layer of security for web pages.
  </p>

  <h2>2. What is it?</h2>
  <p>
    <strong>Concept Explanation</strong>: CSP allows website administrators to define which content
    sources are trustworthy, thereby limiting the resources that a webpage can load and execute. It
    is typically set via HTTP headers, such as <code>Content-Security-Policy</code>.
  </p>
  <p><strong>Three Key Principles</strong>:</p>
  <ol>
    <li>
      <strong>Whitelist Sources</strong>: Only allow content to be loaded from predefined whitelist
      sources.
    </li>
    <li>
      <strong>Restrict Various Resources</strong>: Including scripts, stylesheets, images, media
      files, frames, etc.
    </li>
    <li>
      <strong>Reporting and Monitoring</strong>: Provide a reporting mechanism for policy violations
      to help identify and resolve security issues.
    </li>
  </ol>
  <p><strong>Real-world Example</strong>:</p>
  <ul>
    <li>
      <strong>Background</strong>: A website wants to ensure that only scripts from specific domains
      can be executed.
    </li>
    <li>
      <strong>Solution</strong>: By setting CSP to only allow scripts from specific sources,
      potential malicious injections are prevented.
    </li>
  </ul>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Limitations</strong>: Implementing CSP can pose challenges in website compatibility and
    maintenance, especially when dealing with third-party components.
  </p>
  <p>
    <strong>Optimization Direction</strong>: Continuously refine the precision of policies, while
    developing more user-friendly and flexible configuration methods.
  </p>
  <p>
    <strong>Future Developments</strong>: The evolution of CSP may focus more on automation and
    integrating other security features to enhance the overall security and usability of websites.
  </p>
</article>


Content Security Policy(CSP)

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: The issue of IDOR arises from an application's failure to adequately
    verify whether a user is authorized to access a specific object. This is often associated with
    insecure data access patterns, such as directly using object references from user input (like
    URL parameters).
  </p>
  <p>
    <strong>Comparative State</strong>: In the context of more security-conscious modern application
    development, stricter access controls are usually implemented. However, if these security
    measures are overlooked by developers, IDOR issues can still occur.
  </p>

  <h2>2. What is it?</h2>
  <p>
    <strong>Concept Explanation</strong>: IDOR occurs when an attacker can access data they
    shouldn't by manipulating object references in URLs, form fields, or query parameters. For
    example, accessing other users' data by changing the user ID in a URL.
  </p>
  <p><strong>Defensive Principles</strong>:</p>
  <ol>
    <li>
      <strong>Strict Access Control</strong>: Ensure the application verifies a user's access rights
      before accessing any sensitive object.
    </li>
    <li>
      <strong>Avoid Direct Object References</strong>: Use indirect references (like tokens or
      randomly generated IDs) instead of direct references.
    </li>
    <li>
      <strong>Thorough Input Validation</strong>: Validate all user-supplied inputs to prevent
      malicious manipulation.
    </li>
  </ol>
  <p><strong>Real-world Example</strong>:</p>
  <ul>
    <li>
      <strong>Background</strong>: An online file storage service allows users to access their files
      directly through a URL.
    </li>
    <li>
      <strong>Problem</strong>: Attackers access other users' private files by simply modifying the
      file ID in the URL.
    </li>
    <li>
      <strong>Solution</strong>: Implement role-based access control and use indirect references to
      access files.
    </li>
  </ul>
  <pre>
    <code>
        class UserDetails extends React.Component {
            componentDidMount() {
              const userId = this.props.match.params.id; // User ID from URL
          
              // Dangerous: Fetching user details based on user-modifiable input without proper authorization
              fetch(`/api/users/${userId}`)
                .then(response => response.json())
                .then(data => this.setState({ user: data }));
            }
          
            render() {
              // Render user details
            }
          }         
    </code>
  </pre>
  <h2>3. Where is it going?</h2>
  <p>
    <strong>Challenges</strong>: As applications become more complex, maintaining effective access
    control and preventing IDOR attacks becomes increasingly difficult.
  </p>
  <p>
    <strong>Future Developments</strong>: Develop more advanced security strategies and tools, such
    as using AI to identify and prevent IDOR vulnerabilities.
  </p>
</article>


Insecure Direct Object Reference(IDOR)

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: In React applications, critical security token exposure often results
    from insecure handling and storage of tokens. For instance, storing sensitive tokens in
    client-accessible locations (like localStorage) can lead to exposure.
  </p>
  <p>
    <strong>Comparative State</strong>: In modern web development, as the use of front-end
    frameworks and client-side storage increases, this risk becomes more pronounced. Previously,
    sensitive data was handled more on the server side, with relatively lower exposure risks.
  </p>

  <h2>2. What is it?</h2>
  <p>
    <strong>Concept Explanation</strong>: In React, critical security token exposure can occur if
    sensitive tokens (like JWT tokens, API keys) are stored or transmitted insecurely on the client
    side. This includes, but is not limited to, storage in localStorage, plaintext transmission in
    client-side JavaScript, or insecure usage of HTTP cookies.
  </p>
  <p><strong>Defensive Principles</strong>:</p>
  <ol>
    <li>
      <strong>Secure Storage</strong>: Avoid storing sensitive tokens in locations vulnerable to XSS
      attacks.
    </li>
    <li>
      <strong>Secure Transmission</strong>: Use HTTPS to protect data transmitted between the client
      and the server.
    </li>
    <li>
      <strong>Minimize Exposure</strong>: Only expose tokens on the client side when necessary, and
      handle sensitive data on the server side as much as possible.
    </li>
  </ol>
  <p><strong>Real-world Example</strong>:</p>
  <ul>
    <li>
      <strong>Background</strong>: A web application built with React stores user authentication
      tokens in localStorage.
    </li>
    <li>
      <strong>Problem</strong>: Due to an XSS attack, malicious scripts can access and steal these
      tokens.
    </li>
    <li>
      <strong>Solution</strong>: Switch to securely storing tokens in HTTP-only cookies, thereby
      reducing direct client-side access to sensitive data.
    </li>
  </ul>
  <pre>
    <code>
class UserProfile extends React.Component {
  componentDidMount() {
    // Highly insecure: Exposing a security token in client-side code
    const token = 'secret-security-token';
    fetch(`/api/userdata?token=${token}`)
      .then(response => response.json())
      .then(data => this.setState({ userData: data }));
  }

  render() {
    // Render user profile
  }
}
    </code>
  </pre>

  <h2>3. Where is it going?</h2>
  <p>
    <strong>Challenges</strong>: As React applications become more complex, developers need to
    remain vigilant about securely storing and transmitting tokens.
  </p>
  <p>
    <strong>Future Developments</strong>: There might be more tools and libraries developed to help
    securely manage and store sensitive tokens in React applications.
  </p>
</article>


Security Token Exposure

Unsecured Authentication Logic

<article>
  <h2>1. Where does it come from?</h2>
  <p>
    <strong>Origin</strong>: XSS (Cross-Site Scripting) vulnerabilities exist in all front-end
    frameworks, including React. They occur when an application fails to properly encode or escape
    user input, leading to the embedding and execution of malicious scripts.
  </p>
  <p>
    <strong>Comparative State</strong>: Before the advent of modern front-end frameworks like React,
    XSS attacks were mainly executed by directly inserting malicious code into HTML. React reduces
    this risk by automatically escaping HTML, but XSS threats can still arise if not used properly,
    especially in certain scenarios.
  </p>

  <h2>2. What is it?</h2>
  <p>
    <strong>Concept Explanation</strong>: In React, XSS typically occurs when developers incorrectly
    handle user input, directly inserting it into the component's output, especially when using the
    <code>dangerouslySetInnerHTML</code> property. This can lead to unauthorized code execution,
    such as JavaScript scripts.
  </p>
  <p><strong>Defensive Principles</strong>:</p>
  <ol>
    <li>
      <strong>Safely Handle User Input</strong>: Never trust user input, always sanitize and escape
      all inputs appropriately.
    </li>
    <li>
      <strong>Avoid Using <code>dangerouslySetInnerHTML</code></strong
      >: Use this property sparingly and only when absolutely necessary.
    </li>
    <li>
      <strong>Utilize Security Libraries</strong>: Employ libraries like DOMPurify to clean inputs
      that may contain dangerous content.
    </li>
  </ol>
  <p><strong>Real-world Example</strong>:</p>
  <ul>
    <li>
      <strong>Background</strong>: A social media app allows users to post comments but fails to
      properly handle user inputs.
    </li>
    <li>
      <strong>Problem</strong>: Attackers insert JavaScript code in the comments, which executes
      when other users view the comment.
    </li>
    <li>
      <strong>Solution</strong>: Properly sanitize and escape user inputs to ensure no malicious
      scripts are executed.
    </li>
  </ul>
  <pre>
    <code>
    class UnsafeComponent extends React.Component {
        render() {
          // Extremely dangerous: Directly injecting user-controlled content into the HTML
          return <div dangerouslySetInnerHTML={{ __html: this.props.userInput }} />;
        }
      }
    </code>
  </pre>
  <h2>3. Where is it going?</h2>
  <p>
    <strong>Challenges</strong>: With the ongoing development of React and other front-end
    technologies, there's a continuous need to stay vigilant about new security threats and
    defensive methods.
  </p>
  <p>
    <strong>Future Developments</strong>: Enhanced security features and more intelligent static
    analysis tools may be developed to automatically identify and prevent potential XSS attacks.
  </p>
</article>


< KitSkills />

React | Node | JAVA | AWS

frontEnd SKILLSfrontEnd

< JS />

< FUNCTIONAL PROGRAMMING />

< REACT CORE />

< REACT />

< TYPESCRIPT />

backEnd SKILLSbackEnd (IN DEVELOP)

< JAVA />

< SPRING />

< SQL />

< OBJECT-ORIENTED PROGRAMMING />

devops SKILLSdevops (IN DEVELOP)

< AWS />

others SKILLSothers (IN DEVELOP)

< SECURITY />

< SCRUM/AGILE />

< GIT />

< GIT CORE />