Mastering Apache Kafka

-


Introduction
In today’s data-driven world, managing real-time data efficiently is no longer a luxury—it’s a necessity. Apache Kafka has emerged as a cornerstone for real-time data streaming, empowering businesses to process, store, and analyze data at scale. Whether you’re a beginner or a professional, this comprehensive guide will help you unravel the true potential of Apache Kafka and equip you to implement it effectively in your projects.







Let’s dive in!

What is Apache Kafka?

Apache Kafka is an open-source distributed event streaming platform that enables applications to publish, subscribe, store, and process data streams. Created by LinkedIn and later donated to the Apache Software Foundation, Kafka plays a critical role in high-throughput, low-latency environments.

Why Use Apache Kafka?

  1. Scalability: Kafka’s distributed architecture makes it highly scalable to accommodate growing data needs.
  2. Durability: Kafka ensures fault tolerance by replicating data across multiple nodes.
  3. High Performance: With its ability to handle thousands of messages per second, Kafka is ideal for real-time applications.
  4. Flexibility: Kafka supports a wide variety of use cases, from log aggregation to data integration and analytics.

Core Concepts of Kafka




1. Topics

  • Kafka organizes all its data into topics. Think of a topic as a category or channel where similar data is stored. Topics act as logical containers for messages. You can have multiple topics, and each topic can have multiple partitions for better scalability and parallel processing.

    Why It’s Important:

    • Topics help Kafka organize data in a logical structure. Instead of having one massive data stream, you can separate different kinds of data into distinct topics (e.g., orders, inventory, user logs).
    • Partitions split each topic’s data into smaller chunks, which allows Kafka to scale better, and helps multiple consumers read data in parallel.

    Example:

    For an e-commerce platform, you might have topics like:

    • orders: To track new purchases made by users.
    • inventory: To keep an updated count of stock levels.
    • user_logs: To capture user activity on the platform.

    By categorizing the data into specific topics, different services (like payment gateways, stock management, and user analytics) can access the exact data they need.


2. Producers

  •     Producers are applications or services that generate and publish data to Kafka topics. They send messages (data) to specific topics so that other systems can process it.

    Why It’s Important:

    • Producers are the source of data in Kafka. Any new event, transaction, or data point that happens in your system is sent to Kafka by the producer.
    • Producers are not concerned with who will consume the data or how it’s consumed; they simply send messages to the relevant topic.

    Example:

    A payment gateway in an e-commerce platform acts as a producer. Whenever a user makes a purchase, the payment gateway sends transaction details (like payment amount, user ID, and timestamp) to a payments topic.

    In code, this might look like:

        kafka-console-producer.bat --broker-list localhost:9092 --topic payments


3. Consumers

  • Consumers are services or applications that subscribe to Kafka topics. They read messages from topics and process them.

    Why It’s Important:

    • Consumers are the receivers of the data sent by producers. They take action based on the data they receive from Kafka topics. For example, an analytics service can analyze data, or a notification service can send alerts based on certain triggers.
    • Kafka allows multiple consumers to subscribe to the same topic, which helps distribute workloads efficiently.

    Example:

    An analytics service might subscribe to the user_logs topic to analyze user behavior trends. It reads user activity data and generates reports or triggers recommendations based on user interactions.

    In code, the consumer might look like:

  • kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic user_logs --from-beginning


4. Brokers

  • A Kafka broker is a server that stores data and manages message distribution. Kafka clusters are made up of multiple brokers working together to ensure scalability, availability, and fault tolerance.

    Why It’s Important:

    • Brokers store the actual data (messages) and ensure that consumers can read the data from topics.
    • Kafka brokers are distributed across machines (a Kafka cluster), which helps Kafka scale out. This means data is spread out over multiple brokers, which improves fault tolerance and high availability.

    Example:

    In an e-commerce platform, a Kafka cluster might have multiple brokers that store different partitions of topics (e.g., orders, inventory, user_logs). Each broker stores messages for specific partitions, but consumers can access data from any broker in the cluster.


5. Zookeeper

  • ZooKeeper was originally used to coordinate and manage Kafka brokers. It acts as a distributed coordination service that tracks which brokers are part of the Kafka cluster, ensures brokers are functioning properly, and helps maintain Kafka’s metadata (e.g., topic configurations, partition information).

    Why It’s Important:

    • ZooKeeper ensures that Kafka brokers work together seamlessly in a distributed environment.
    • It helps Kafka manage failover, ensuring that if one broker goes down, another can take over, making sure data is still available and consumers can keep reading from Kafka.
    • ZooKeeper also ensures that Kafka can recover from crashes and maintains metadata consistency across the cluster.

    Example:

    Let’s say one Kafka broker in the e-commerce platform goes down. ZooKeeper will help the Kafka cluster to recognize the failure and reassign partitions to other healthy brokers, ensuring data is still available for consumers.

    However, Kafka is moving away from ZooKeeper in newer versions and will be replacing it with Kafka's own KRaft mode (Kafka Raft), which will handle all of these responsibilities internally.



6. Partitions

Zookeeper Partitions break a topic into smaller parts for scalability and fault torerance.

Partitions

In Kafka, Topics are further divided into partitions. A partition is a basic unit of parallelism in Kafka. Each partition is an ordered, immutable sequence of messages. Data within a partition is stored sequentially, and each message within the partition has a unique identifier known as an offset.

Why Partitions Are Important:

  1. Scalability: Partitions allow Kafka to scale horizontally. By splitting data into partitions, Kafka can store data across multiple brokers in a cluster and distribute the workload for both producers and consumers.

  2. Parallelism: Partitions allow consumers to read messages in parallel. Multiple consumers in a consumer group can read from different partitions of the same topic at the same time. This leads to better throughput and processing speed.

  3. Data Ordering: Kafka guarantees ordering of messages within a partition. If you produce messages to the same partition, Kafka ensures that they are consumed in the same order they were produced. However, there is no guarantee of ordering across different partitions of the same topic.

  4. Fault Tolerance: Kafka replicates partitions across multiple brokers for fault tolerance. If one broker fails, another broker can serve the data from the replicated partition.

How Partitions Work:

  • Producer's Role with Partitions: When a producer sends a message to Kafka, it writes the message to a specific partition of a topic. The assignment of messages to partitions can be done in several ways:

    • Round-robin: Kafka evenly distributes messages across partitions.
    • Key-based: Kafka assigns messages to partitions based on the key (for example, a user ID). This ensures that all messages for a specific key are sent to the same partition, which guarantees message ordering for that key.

  • Consumer's Role with Partitions: Consumers read messages from partitions. Each partition is consumed by a single consumer in a consumer group, but multiple consumers can consume from different partitions of the same topic simultaneously.

Example of Partitions in Action:

Consider an e-commerce platform that has a orders topic. This topic is partitioned to improve performance, as shown below:

  • Topic: orders
  • Partitions:
    • Partition 0: Stores orders placed by users in the North region.
    • Partition 1: Stores orders placed by users in the South region.
    • Partition 2: Stores orders placed by users in the East region.

In this case, each order might be sent to a partition based on the user's region (for example, using a region code as the key). This ensures that orders for a specific region are always written to the same partition and can be consumed in the correct order by the consumer.

How Partitions Enhance Performance:

  • Parallel Processing: If there are three partitions for the orders topic, then three consumers can read from those partitions at the same time, leading to parallel processing. If each partition contains one-third of the total messages, the total processing time is reduced because multiple consumers can work on different parts of the topic simultaneously.

  • Data Distribution: Since partitions are distributed across Kafka brokers, Kafka ensures the load is balanced. For example, if one broker holds multiple partitions, it will distribute the data storage and processing load evenly across the cluster.

Partitions in Kafka: Key Features

Feature Explanation
Parallelism Kafka allows multiple consumers to read from different partitions simultaneously, speeding up processing.
Ordering Kafka guarantees message order within a partition, but not across partitions of the same topic.
Scalability More partitions allow for better horizontal scaling, enabling Kafka to handle higher volumes of data.
Fault Tolerance Kafka replicates partitions across multiple brokers. If one broker fails, another broker will serve the data.

Example: Kafka with Partitions in an E-commerce System

Let’s take a closer look at a real-world e-commerce example where partitions help improve performance and scalability.

  • Topic: user_activity
  • Partitions:
    • Partition 0: Stores activities of users in Region A.
    • Partition 1: Stores activities of users in Region B.
    • Partition 2: Stores activities of users in Region C.

Here’s how it works:

  • When a user from Region A logs into the website, the user_activity message is sent to Partition 0.
  • The consumer reading from Partition 0 might be a service that tracks user engagement in Region A. Another consumer reading from Partition 1 processes data for Region B.

With multiple partitions, we ensure that the system can handle large volumes of user activity, each partition being processed independently by different consumers in parallel. This allows the system to scale as the user base grows.

In Summary:

  • Topics are categories or channels where data is stored in Kafka.
  • Producers send data to specific topics, acting as the source of information.
  • Consumers retrieve data from topics and process it, such as performing analytics or triggering actions.
  • Brokers are the servers that manage data storage and distribution, ensuring Kafka is scalable and fault-tolerant.
  • ZooKeeper (or KRaft in newer versions) coordinates Kafka’s distributed brokers and ensures the Kafka cluster runs smoothly.

  • Partitions: which is a crucial concept in Kafka for scalability and parallelism.



Kafka Use Cases

1. Real-Time Analytics

Companies leverage Kafka to monitor user activities, detect fraud, or track performance metrics in real time.

Example:

Netflix uses Kafka to analyze user viewing patterns and recommend personalized content instantly.

2. Log Aggregation

Kafka simplifies the collection and storage of log data from multiple servers or applications.

Example:

A cloud service provider uses Kafka to centralize logs for debugging and monitoring server health.

3. Event-Driven Architectures

Kafka enables seamless communication between microservices, ensuring that events trigger specific actions across the system.

Example:

In a ride-hailing app, Kafka tracks ride requests and updates drivers about nearby users in real time.

How Kafka Works: The Architecture

  1. Publish-Subscribe Model: Producers send data to a topic, and consumers retrieve data asynchronously.
  2. Partitions and Replication: Each topic is divided into partitions for parallel processing. Data is replicated across brokers for fault tolerance.
  3. Offset Tracking: Kafka tracks the position of a consumer in a topic using offsets, ensuring no messages are missed or processed twice.

Getting Started with Kafka: Step-by-Step Guide

  1. Setup Kafka: Install Kafka on your local machine or a server.
  2. Define Topics: Identify the data streams and create topics accordingly.
  3. Build Producers and Consumers: Develop applications to send and receive messages.
  4. Monitor Performance: Use tools like Kafka Manager to oversee cluster health.

Best Practices for Using Kafka

  1. Optimize Partition Count: Choose the right number of partitions for your workload.
  2. Secure Your Cluster: Implement authentication and encryption to safeguard data.
  3. Monitor Latency: Regularly check for delays in message delivery.
  4. Keep Consumers Efficient: Avoid slow consumers, as they can cause message backlogs.


This guide is designed for beginners and will walk you through everything from setting up Kafka to creating clusters, sending messages, and understanding consumer groups. Each step includes clear explanations, commands, and outputs to make your learning process smooth.


1. Setting Up Apache Kafka

Kafka requires two main components to run: Zookeeper, which manages cluster metadata, and Kafka Broker, which stores and serves data streams.

Step 1: Download and Install Kafka

                    tar -xzf kafka_2.13-3.5.0.tgz
                    cd kafka_2.13-3.5.0

Step 2: Start Zookeeper

  • Kafka depends on Zookeeper for managing broker metadata. 
  • Run the following command to start Zookeeper:
  • My file location is C:\kafka_2.13-3.9.0\bin\windows I am running my all command from here

    zookeeper-server-start.bat ..\..\config\zookeeper.properties

  • Explanation: This starts the Zookeeper service, which is necessary for Kafka to operate in a distributed environment.

Step 3: Start Kafka

  •     Now, start the Kafka server:
        kafka-server-start.bat ..\..\config\server.properties
  • Explanation: This starts a Kafka broker, which is responsible for managing data streams (topics).

Step 4: Verify Installation

  • Check if Kafka is running by listing all topics (there won’t be any yet):

            kafka-topics.bat --list --bootstrap-server localhost:9092
  • Output: If no topics are listed, it means Kafka is running correctly.

2. Creating and Managing Kafka Topics

  • Kafka organizes data into topics, which act like categories or channels for messages.

Creating a Topic

  • Use the following command to create a topic:

      kafka-topics.bat --create --topic my-topic --bootstrap-server localhost:9092 --replication-factor 1 --partitions 3

  • Output:
                

Explanation:

  • --topic: The name of the topic (e.g., test_topic).
  • --partitions: Number of partitions (splits the topic into parts for parallel processing).
  • --replication-factor: Number of replicas for fault tolerance.

Listing Topics

        kafka-topics.bat --list --bootstrap-server localhost:9092
  • Explanation: Lists all the existing topics.

Describing a Topic

        bin/kafka-topics.bat --describe --topic my_topic --bootstrap-server localhost:9092

Output:

Topic: my_topic  
PartitionCount: 3  
ReplicationFactor: 1  
Configs:
  • Explanation: This shows details like the number of partitions and replicas for the specified topic.


Produce and Consume Messages

  • Start a producer to send messages:

    kafka-console-producer.bat --broker-list localhost:9092 --topic my-topic 

  • Start a consume to read messages:

    kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic my-topic --from-beginning


Let's play around the producer and consumer:
In producer prompt I produce the data like mango and gauva, and you will see consumer is consuming the data successfully!





  • Now, here are 2 things in the consumer command, if I say I dont want messages from the beginning, then my command will be

     kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic my-topic







3. Sending Kafka Messages with Keys via Command Line

  • Kafka producers send messages to topics. Let’s learn how to send messages with keys.

    1.    Starting Kafka:

            Ensure Kafka brokers and ZooKeeper are running.

             zookeeper-server-start.bat ..\..\config\zookeeper.properties 

             kafka-server-start.bat ..\..\config\server.properties 

    2.    Create a Topic:

            Create a topic named my_topic with 4 partitions
                
        kafka-topics.bat --create --topic fruits --bootstrap-server localhost:9092 --replication-factor 1 --partitions 4

              Start a Producer

              kafka-console-producer.bat --broker-list localhost:9092 --topic fruits --property "key.separator=-" --property "parse.key=true"

       Explanation:

  • --property "parse.key=true": Enables sending key-value pairs.
  • --property "key.separator=:": Specifies the separator between the key and the value.

        Send Messages

        After running the above command, enter the following messages:

        hello-apple
        hello-banana
        hello-kiwi
        bye-mango
        bye-gauva

 
    Start a Consumer to Read Messages
        kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic fruits --from-beginning -property "key.separator=-" --property "print.key=false"

     Explanation:

  • --from-beginning: Reads all messages from the start of the topic.
  • --property "print.key=true": Displays the keys along with the values.

    Output:




     Explanation:
  • First window - Zookeer
  • second window - kafka server
  • Third window - Producer
  • Forth window - Consumer

4. Setting Up a Kafka Cluster with Three Brokers

A Kafka cluster consists of multiple brokers to improve performance and reliability.




Step 1: Duplicate Configuration Files

config/server.properties config/server.properties - this will be already there.

Create configuration files for additional brokers:

cp config/server.properties config/server1.properties  
cp config/server.properties config/server2.properties

Step 2: Edit Configuration Files

Edit each file to assign unique broker.id, log.dirs, and listeners:

In server1.properties:

broker.id=1  
log.dirs=/tmp/kafka-logs1  
listeners=PLAINTEXT://:9093

In server2.properties:

broker.id=2  
log.dirs=/tmp/kafka-logs-2  
listeners=PLAINTEXT://:9094  


Example:
Broker 0: server.0.properties with broker ID 0, port 9092, and unique log directory.
Broker 1: server.1.properties with broker ID 1, port 9093, and another log directory.
Broker 2: server.2.properties with broker ID 2, port 9094, and a separate log directory.



Step 3: Start Additional Brokers

Start each broker:

Broker 0: kafka-server-start.bat ..\..\config\server1.properties
Broker 1: kafka-server-start.bat ..\..\config\server1.properties
Broker 2: kafka-server-start.bat ..\..\config\server1.properties



Step 4: Verify Cluster Configuration

Describe a topic to verify partition leaders:

bin/kafka-topics.sh --describe --topic test_topic --bootstrap-server localhost:9092

Output:

Topic: test_topic  
Partition: 0 Leader: 0 Replicas: 0 Isr: 0  
Partition: 1 Leader: 1 Replicas: 1 Isr: 1  
Partition: 2 Leader: 2 Replicas: 2 Isr: 2
  • Explanation: Each partition is assigned a leader and replicas are distributed across brokers.

  • you must have your zookeeper in running state:
        zookeeper-server-start.bat ..\..\config\zookeeper.properties

  • Here’s how you can create a topic with a replication factor of three and three partitions:

        kafka-topics.bat --create --topic gadgets --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --replication-factor 3 --partitions 3




1.Producer: Use the Kafka producer to send messages to the topic:

kafka-console-producer.bat --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --topic gadgets


  • You can send messages such as Hello, Laptop, Mouse, and Monitor, and they will be published to the topic’s partitions.

2.Consumer: Use the Kafka consumer to read messages from the topic:

kafka-console-consumer.bat --bootstrap-server localhost:9092,localhost:9093,localhost:9094 --topic gadgets --from-beginning






  • You will see in C:\tmp\kafka-logs there are 3 folders created, and same in C:\tmp\kafka-logs1 and C:\tmp\kafka-logs2




5. Kafka Offsets and Consumer Groups

Kafka tracks the position of each consumer in a topic using offsets.

Consumer Groups

A group allows multiple consumers to share the workload of reading a topic.

Start two consumers in the same group:

bin/kafka-console-consumer.sh --topic test_topic \
    --bootstrap-server localhost:9092 \
    --group test_group

Check consumer group details:

bin/kafka-consumer-groups.sh --describe --group test_group --bootstrap-server localhost:9092

Output:

GROUP           TOPIC      PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG
test_group      test_topic 0          2               3               1

Explanation:

  • CURRENT-OFFSET: Position of the last consumed message.
  • LAG: Messages not yet consumed by the group.

6. Monitoring Kafka

Kafka provides tools for monitoring its components.

Monitor Topics

bin/kafka-topics.sh --describe --bootstrap-server localhost:9092
  • Explanation: Displays details about all topics.

External Monitoring Tools

  • Prometheus and Grafana: For visual dashboards and alerts.
  • Kafka Manager: Simplifies monitoring cluster health and managing topics.

Conclusion

Apache Kafka is a versatile platform for building real-time data pipelines. With a solid understanding of its concepts and commands, you can leverage its full potential for various use cases. Start experimenting today, and you'll quickly see how Kafka transforms the way data is processed.


Kafka Summary Table


Here’s a detailed summary table covering Kafka's core components, their roles, commands, outputs, and typical usage scenarios:

Component Role Key Commands & Actions Output Usage Scenario
Producer The Producer is responsible for sending data (messages) to Kafka topics. This is the starting point of data flow in Kafka. Command: 
kafka-console-producer.bat --broker-list localhost:9092 --topic <topic>
 Action: A producer can also use libraries like Java’s send() method to publish messages to topics.		 Confirmation that messages have been sent to Kafka for a particular topic. Real-Time Data Ingestion: For instance, sending web logs, user actions, or transaction data to Kafka for processing.
Consumer The Consumer reads and processes messages from Kafka topics. It listens for messages published by producers and acts upon them. Command:
kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic <topic>
 Action: Consumers can also use Kafka’s consumer API (e.g., poll()) to retrieve messages programmatically.		 Data from a Kafka topic (e.g., logs, user actions). It displays messages to the console or processes them in an app. Data Processing & Analytics: Analyzing incoming data streams in real-time, such as monitoring transactions or analyzing user interactions.
Topic A Topic is like a channel where data/messages are stored in Kafka. Topics allow Kafka to organize data streams logically. No direct command to create a topic in the table; typically created during producer actions or using Kafka Admin API. Organized data stream, messages ordered by partitions. Data Segmentation: Different types of data (e.g., logs, user events, orders) are sent to different topics for easier management.
Broker A Broker is a Kafka server that stores data and serves messages to consumers. A Kafka cluster consists of multiple brokers for reliability and scalability. Command: No direct command; brokers are configured in the Kafka cluster setup and handled by the system. Reliable storage of Kafka data across multiple brokers for fault tolerance and availability. Scalability & Fault Tolerance: Distributing the load of handling data across multiple brokers, ensuring high availability and no data loss.
Partition A Partition is a part of a topic. Kafka topics are split into partitions to allow parallel processing, improving scalability and fault tolerance. Managed by Kafka when topics are created. Can be configured using Admin API to increase the number of partitions for a topic. Distributed data across multiple partitions, improving parallelism. Load Distribution: When consumers read data from Kafka, partitions allow multiple consumers to read data simultaneously from different sections of a topic.
Offset An Offset is a unique identifier assigned to each message in a partition. It keeps track of the message position for each consumer. No direct command; automatically managed by Kafka when messages are produced and consumed. Consumers can commit offsets manually or automatically. A reference number that indicates the position of a consumer in the topic’s partition. Message Tracking: Ensures that consumers read messages from the correct position, even after a failure or restart.
ZooKeeper (deprecated) ZooKeeper was used for managing Kafka cluster metadata (i.e., brokers, topics, and partitions). However, Kafka now uses its internal Raft protocol (KRaft mode) for coordination. Command:
zookeeper-server-start.bat ..\..\config\zookeeper.properties		 Cluster metadata, coordination info between brokers. Cluster Coordination: Previously, it was responsible for managing and coordinating Kafka brokers, but is now being replaced by KRaft.
Kafka Connect Kafka Connect is used to easily integrate Kafka with external systems, such as databases, data lakes, and other streaming platforms. Command: connect-standalone.sh for running a single Kafka Connect worker or connect-distributed.sh for running multiple workers. Real-time data pipelines from external systems to Kafka or vice versa. ETL Pipelines: Streaming data from databases (e.g., MySQL) into Kafka or from Kafka to systems like Hadoop, Elasticsearch, etc.
Kafka Streams Kafka Streams is an API that allows you to build real-time stream processing applications that process data within Kafka. Action: Use Java’s KStream, KTable, filter(), map(), aggregate(), etc., to manipulate streams in real-time. Processed, transformed, or aggregated data, which can be written back to Kafka topics. Stream Processing: Real-time processing of data like aggregating sensor data, detecting anomalies, or performing continuous calculations.
KSQLDB KSQLDB is an SQL-like language for querying and processing data in Kafka in real time. It is an interactive query tool used for stream processing. Command: CREATE STREAM or CREATE TABLE, then SELECT * FROM <stream> for querying data from Kafka streams. Real-time query results directly from Kafka streams. Real-Time Analytics: Using SQL to filter, aggregate, and join data in real-time, e.g., running queries on stock market data or real-time order streams.
Kafka Admin The Kafka Admin tool allows you to manage and configure Kafka resources such as topics, partitions, and broker settings. Command: kafka-topics.sh (create, delete, list topics), kafka-configs.sh (modify topic configurations). Updates to Kafka topics or broker configurations. Cluster Management: Creating and modifying Kafka topics, adjusting partition sizes, or changing topic configurations for scalability.
Kafka Monitoring Kafka Monitoring tools (like Prometheus and Grafana) are used to track and visualize Kafka metrics such as message throughput, consumer lag, and broker health. Command: Use Prometheus JMX exporter (kafka-run-class.sh kafka.tools.JmxTool) to expose Kafka metrics to Prometheus, then visualize them in Grafana. Metrics on consumer lag, broker health, and throughput are displayed in real-time dashboards. Cluster Health Monitoring: Ensuring Kafka is operating smoothly by monitoring lag, throughput, and other performance metrics.
Kafka Producer API The Kafka Producer API allows developers to send messages to Kafka topics programmatically, making it possible to integrate Kafka with applications. Action: Use send() method in Java/Scala or produce() in Python. Programmatically sent messages to Kafka topics. Automated Data Publishing: Sending data from web applications, IoT devices, or other systems directly into Kafka topics for real-time processing.
Kafka Consumer API The Kafka Consumer API provides developers with the tools to read and process messages from Kafka topics. Action: Use poll() method to consume messages from a Kafka topic. Programmatically consumed messages for processing or triggering actions. Automated Data Consumption: Processing Kafka messages in real-time, such as processing transactions, feeding data to analytics systems, or triggering events.



This blog is packed with beginner-friendly explanations, making it easy to understand every command and concept. Let me know if anything else needs clarification in the comment section!


Happy coding!

Comments

Post a Comment