DEV Community: Kavishka Dinajara

Building a Modern Authentication System with Supabase, Ballerina, and Next.js

Kavishka Dinajara — Thu, 10 Oct 2024 16:33:38 +0000

In this article, I'll share my journey of integrating Supabase with Ballerina as a backend and Next.js as the frontend framework to create a modern authentication system. This approach not only allows for a streamlined user experience but also leverages the power of JWT (JSON Web Tokens) for secure authentication.

Overview of the Tech Stack

Supabase: An open-source Firebase alternative that provides a backend-as-a-service, including authentication, database management, and real-time functionalities.
Ballerina: A programming language specifically designed for cloud-native application development, making it perfect for handling API integrations and microservices.
Next.js: A React-based framework that enables server-side rendering and static site generation, providing an excellent user experience.

Setting Up the Project

1. Initializing Supabase

I started by creating a Supabase project and setting up the database. I defined a users table with fields for the username and password. The password would be stored securely as a hash.

2. Connecting Ballerina to Supabase

In Ballerina, I created a service to handle user registration and login. Here’s a snippet of the code to establish a connection to the Supabase PostgreSQL database:

import ballerina/http;
import ballerinax/postgresql;

// Supabase DB connection config
configurable string host = "your_host";
configurable int port = 5432;
configurable string username = "your_username";
configurable string password = "your_password";
configurable string databaseName = "your_database";

service /auth on new http:Listener(9090) {
    final postgresql:Client dbClient;

    public function init() returns error? {
        self.dbClient = check new (host, username, password, databaseName, port);
    }
}

3. User Registration and Hashing Passwords

For user registration, I utilized the crypto module in Ballerina to hash the passwords securely. Here's how I handled user registration:

resource function post register(http:Caller caller, http:Request req) returns error? {
    json payload = check req.getJsonPayload();
    string username = (check payload.username).toString();
    string plainPassword = (check payload.password).toString();

    // Hash the password
    byte[] hashedPassword = check crypto:hashSha256(plainPassword.toBytes());

    // Insert the user into the database
    sql:ExecutionResult result = check self.dbClient->execute(
        `INSERT INTO users (username, password) VALUES (${username}, ${hashedPassword.toBase16String()})`
    );

    if result.affectedRowCount == 1 {
        check caller->respond({ message: "Registration successful" });
    } else {
        check caller->respond({ message: "Registration failed" });
    }
}

4. User Login and JWT Generation

For the login functionality, I queried the database to retrieve the hashed password, compared it with the entered password, and generated a JWT token upon successful authentication:

resource function post login(http:Caller caller, http:Request req) returns error {
    json payload = check req.getJsonPayload();
    string username = (check payload.username).toString();
    string plainPassword = (check payload.password).toString();

    // Retrieve the user from the database
    stream<record {|anydata...;|}, sql:Error?> resultStream = self.dbClient->query(
        `SELECT password FROM users WHERE username = ${username}`
    );

    // Verify the password and generate JWT token
    // (Code to validate the password and generate JWT)
}

5. Implementing the Frontend with Next.js

On the frontend, I built a registration page using React and styled it with Tailwind CSS. The form captures the username and password, sending the data to the Ballerina backend for processing.

Here’s a snippet of the registration form component:

import React, { useState } from 'react';

const RegisterPage = () => {
  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");

  const handleSubmit = async (event) => {
    event.preventDefault();
    const response = await fetch('/auth/register', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ username, password }),
    });
    const data = await response.json();
    // Handle response...
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" value={username} onChange={(e) => setUsername(e.target.value)} placeholder="Username" />
      <input type="password" value={password} onChange={(e) => setPassword(e.target.value)} placeholder="Password" />
      <button type="submit">Register</button>
    </form>
  );
};

export default RegisterPage;

Conclusion

This project has taught me the intricacies of handling authentication securely and effectively using modern technologies. Integrating Supabase with Ballerina and Next.js has provided me with a robust solution for user management.

I hope this article inspires you to explore similar integrations and improve your skills in building modern web applications. If you have any questions or feedback, feel free to reach out!

My Journey Learning TypeScript and JavaScript

Kavishka Dinajara — Sat, 28 Sep 2024 17:44:07 +0000

Introduction

As a web developer, learning JavaScript (JS) is essential because it powers the modern web. But as I dove deeper into development, I realized that TypeScript (TS) could help me write more reliable, maintainable code. In this post, I’m excited to share my journey learning both JavaScript and TypeScript, the challenges I faced, and the exciting things I discovered along the way.

1. Starting Out with JavaScript

When I first started learning JavaScript, I was overwhelmed by its versatility. JavaScript is known for being the language of the web, capable of everything from making interactive websites to building full-stack applications.

Key Concepts in JavaScript

Variables and Data Types: Understanding var, let, and const and the types of data (strings, numbers, arrays, etc.).
Functions: Writing reusable code through functions.
Objects and Arrays: Learning how JavaScript handles data through key-value pairs and lists.
Control Structures: Using loops and conditional statements to control the flow of your application.
DOM Manipulation: How JavaScript interacts with HTML to create dynamic content.

Example: JavaScript Basics

const name = "Kavishka";
function greetUser(name) {
  console.log(`Hello, ${name}!`);
}
greetUser(name);  // Output: Hello, Kavishka!

This was one of the first things I learned, and it helped me understand the power of JavaScript in building dynamic applications. With this foundation, I could build small interactive websites and start experimenting with frontend frameworks.

2. Discovering TypeScript

After becoming comfortable with JavaScript, I noticed that larger applications could get tricky. This is when I discovered TypeScript—a superset of JavaScript that adds static types, making the code more predictable and easier to debug.

Why TypeScript?

Type Safety: TypeScript forces you to declare data types (strings, numbers, arrays), which prevents common runtime errors.
Code Readability: It helps me and my team understand what the code is supposed to do without guessing data types.
Tooling: TypeScript's support for IDE features like autocompletion and better error handling made me more productive.

Example: Transitioning from JS to TS

JavaScript:

function addNumbers(a, b) {
  return a + b;
}
console.log(addNumbers(5, "10"));  // Output: "510" (Oops! String concatenation)

TypeScript:

function addNumbers(a: number, b: number): number {
  return a + b;
}
console.log(addNumbers(5, 10));  // Output: 15 (Correct result)

Adding type annotations to functions and variables helped catch errors early, making my codebase more robust. As someone who transitioned from JS to TS, I found that it adds structure without overwhelming complexity.

3. Object-Oriented Programming in TypeScript

JavaScript has always supported object-oriented programming (OOP), but TypeScript enhances it by introducing better tools like classes, interfaces, inheritance, and encapsulation. I found TypeScript's OOP features especially helpful in organizing complex code.

Example: OOP in TypeScript

class Animal {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  makeSound() {
    console.log(`${this.name} makes a sound`);
  }
}

class Dog extends Animal {
  makeSound() {
    console.log(`${this.name} barks`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound();  // Output: Buddy barks

TypeScript allows you to build robust OOP patterns, making it easier to scale and maintain large applications, which was a big leap forward in my development journey.

4. Advanced TypeScript Features

As I explored more, I realized how powerful TypeScript can be with its advanced features like:

Generics: Writing reusable code that works with any data type.
Interfaces: Defining the shape of objects and making code more structured.
Type Aliases: Creating custom types for better readability.

Example: Using Generics

function identity<T>(arg: T): T {
  return arg;
}
console.log(identity<number>(10));  // Output: 10

Generics allow you to write flexible code that works with different types, making it a valuable tool for building reusable functions and components.

5. Challenges Along the Way

One of the challenges I faced was managing the complexity that comes with learning TypeScript’s strict typing system. At first, it felt like I was writing more code, but I quickly realized that this additional effort paid off in preventing bugs. TypeScript also forced me to think more carefully about my data structures, which improved my overall coding practices.

6. Practical Tips for Learning JavaScript and TypeScript

If you're starting with JavaScript and TypeScript, here are a few tips that helped me:

Practice, Practice, Practice: The best way to learn is by building small projects. Start with simple web pages in JavaScript and then add TypeScript for better type safety.
Embrace Errors: Don’t get discouraged by TypeScript's strictness. Those red squiggly lines in your IDE are there to help you write better code!
Learn by Example: Use examples from documentation and tutorials to understand key concepts, then modify them to fit your needs.
Pair Programming: Discussing code with others helped me solidify concepts and learn new tricks.

Conclusion

Learning JavaScript and TypeScript has been an exciting and rewarding journey. JavaScript gave me the flexibility to build interactive web applications, while TypeScript added the structure and safety I needed for more complex projects. Combining these two technologies has improved my code quality and helped me grow as a developer.

I’m excited to continue my journey with TypeScript and JavaScript, and I hope my experience helps others who are also on the path of learning these powerful tools. If you're just starting out, keep experimenting, building, and pushing your limits—there’s always more to learn!

What’s Next?

Next, I plan to dive deeper into Next.js with TypeScript and experiment with backend TypeScript for full-stack applications. Stay tuned for my upcoming posts on that!

Unlocking AI Potential with Azure: My Experience at the Season of AI - NIBM Galle

Kavishka Dinajara — Sun, 01 Sep 2024 14:06:17 +0000

Introduction: A Global AI Initiative

Artificial Intelligence is reshaping the world, and being part of the journey is both thrilling and essential. On the 31st of August 2024, I had the privilege of attending the "Season of AI" event at the NIBM Galle campus—a part of Microsoft's global AI initiative aimed at empowering students with the latest advancements in AI technology. The event focused on using tools like Python, .NET, C#, VS Code, and Azure to build innovative AI-driven applications. This hands-on experience gave me a unique insight into how these technologies come together to shape the future of AI.

Event Overview: Tools, Technologies, and Inspiration

The event was presented by Dileepa Bandara, a Gold Microsoft Learn Student Ambassador, who provided us with a wealth of knowledge on AI and cloud computing. We delved into the world of Azure, exploring its capabilities and how it integrates with OpenAI to unlock endless possibilities.

The focus of the event was on practical application, and we were introduced to Azure AI Studio, a cutting-edge 'code-first' platform for building generative AI copilots. The session emphasized the importance of hands-on experience, encouraging us to set up our environments with Python or C#, VS Code, and the necessary extensions.

For anyone looking to dive into AI, this event was a goldmine. With tools like Azure and OpenAI at our fingertips, the potential to create innovative solutions felt more accessible than ever.

The AdumKade Experience: Bringing AI to Fashion

One of the most exciting parts of the event was the practical session where we created a small AI application named AdumKade. AdumKade is a fashion-focused application designed to revolutionize the way we interact with clothing choices. This app wasn't just about showcasing AI capabilities—it was about making AI work for real-world applications.

Here's what we built:

AI Assistant: A virtual assistant that helps users with fashion advice, guiding them through different clothing styles and trends.
Clothing Image Generator: Leveraging the power of generative AI, this feature creates clothing images based on user input, offering a personalized experience.
Chatbot: A conversational AI that interacts with users, answering their questions, and providing recommendations in real-time.

Building AdumKade was both challenging and rewarding. It demonstrated how AI could be seamlessly integrated into daily life, offering practical solutions with a creative twist.

Key Learnings: AI, Azure, and the Future

The "Season of AI" event was more than just a workshop—it was a glimpse into the future of technology. Azure's integration with AI tools like OpenAI showcases how cloud computing is becoming the backbone of modern AI development. The event emphasized a 'code-first' approach, empowering developers to create without limits.

I also learned how important it is to stay adaptable. AI is a rapidly evolving field, and tools like Azure AI Studio are pushing the boundaries of what we can achieve. This experience has inspired me to continue exploring AI, not just as a technology but as a tool for innovation.

Practical Insights: Applying What I've Learned

The knowledge and experience gained from this event have already begun to influence my approach to projects. I see the potential for AI in various fields, from fashion to more complex applications like data analysis and customer interaction platforms.

With tools like Azure and OpenAI, the only limit is our imagination. The hands-on experience of creating AdumKade has sparked ideas for future projects, and I'm eager to dive deeper into AI development.

Conclusion: Embrace the AI Revolution

Attending the "Season of AI" event at NIBM Galle was an enriching experience that opened my eyes to the vast potential of AI and cloud computing. I encourage anyone interested in technology to participate in such events, as they provide invaluable knowledge and networking opportunities.

If you're passionate about AI, don't miss the chance to get involved. Whether you're a seasoned developer or just starting, events like these are a perfect platform to hone your skills and explore new possibilities. And who knows—you might even walk away with some great prizes, like a $100 Azure voucher or a LinkedIn Premium subscription!

Final Thoughts:

Looking back, this event has set the stage for my future endeavors in AI development. It's an exciting time to be in tech, and with the tools and knowledge I've gained, I'm ready to take on new challenges and innovate in ways I never thought possible.

Thank you to the organizers, speakers, and fellow participants who made the "Season of AI" event an unforgettable experience. I look forward to applying what I've learned and continuing this journey into the world of AI.

🚀 Level Up Your Web Development with Next.js

Kavishka Dinajara — Sun, 25 Aug 2024 06:29:04 +0000

Next.js has quickly become a go-to framework for building React applications. It's packed with features that make web development faster, more efficient, and scalable. In this post, I'll dive into why Next.js is an essential tool for developers and how it can supercharge your projects.

Why Next.js? 🤔

Next.js is more than just a React framework. It provides a suite of features that make it stand out:

Hybrid Rendering: Combine static site generation (SSG) and server-side rendering (SSR) effortlessly. This flexibility allows you to optimize performance and SEO.
Built-In API Routes: Need a backend for your frontend? Next.js has you covered with built-in API routes, making it easier to handle serverless functions.
Automatic Code Splitting: Only load what you need. Next.js automatically splits your code, reducing the initial load time and improving user experience.
Dynamic Routing: File-based routing makes dynamic routing a breeze. No more complex configurations – just drop in your files, and Next.js handles the rest.

Getting Started with Next.js

Here’s a quick guide to get you started with Next.js:

Installation:

   npx create-next-app@latest my-nextjs-app
   cd my-nextjs-app
   npm run dev

File-Based Routing: Simply create a file in the pages directory, and it automatically becomes a route:

   // pages/about.js
   export default function About() {
     return <h1>About Us</h1>;
   }

Access it via http://localhost:3000/about.

API Routes: Create a new file under pages/api to add serverless functions:

   // pages/api/hello.js
   export default function handler(req, res) {
     res.status(200).json({ message: 'Hello, Next.js!' });
   }

Access the API at http://localhost:3000/api/hello.

Real-World Use Cases

Next.js is perfect for various use cases:

E-commerce Sites: Dynamic routing and server-side rendering enhance performance and SEO, which are critical for online stores.
Blogs and Portfolios: Hybrid rendering lets you combine static pages with dynamic content seamlessly.
Enterprise Applications: With built-in API routes, you can build complex applications that scale easily.

Conclusion

Next.js is a powerful tool that simplifies modern web development. Whether you're building a small personal project or a large-scale application, Next.js provides the flexibility and performance you need. If you haven't explored it yet, now is the time!

Happy coding! 💻

What I Learned Today: Exploring JavaScript, TypeScript, Node.js, and Project Updates

Kavishka Dinajara — Thu, 15 Aug 2024 16:24:26 +0000

Understanding JavaScript

Today, I delved deeper into JavaScript, the versatile and widely-used programming language that powers much of the web. JavaScript is known for its dynamic typing, prototype-based object orientation, and first-class functions. It’s the backbone of interactive web pages and is used extensively in both client-side and server-side development. Key takeaways about JavaScript listed following.

Dynamic Typing: JavaScript doesn’t require explicit type definitions, allowing variables to hold any type of data.
Event-Driven: It handles asynchronous events efficiently, making it perfect for dynamic web applications.
Cross-Platform Compatibility: JavaScript runs seamlessly in any web browser and on servers via environments like Node.js.

Discovering Node.js

I also explored Node.js, a powerful runtime environment that allows JavaScript to run on the server side. Node.js enables developers to use JavaScript for backend development, creating scalable and high-performance applications.

Key Features of Node.js

Asynchronous and Event-Driven: Node.js uses a non-blocking I/O model, which makes it lightweight and efficient. It can handle multiple simultaneous connections without getting bogged down.
Single-Threaded but Scalable: Despite operating on a single thread, Node.js can efficiently manage many concurrent connections due to its event-driven architecture.
V8 JavaScript Engine: Node.js uses the V8 engine developed by Google, which compiles JavaScript into machine code for faster execution.
NPM (Node Package Manager): Node.js comes with npm, a package manager that provides access to a vast ecosystem of open-source libraries and tools.

Discovering TypeScript

I also explored TypeScript, a statically typed superset of JavaScript developed by Microsoft. TypeScript enhances JavaScript by adding optional static types, interfaces, and other features that improve the development experience, especially for large codebases. Key benefits of TypeScript are following.

Static Typing: TypeScript’s type annotations help catch errors at compile time, providing a safer and more predictable coding environment.
Enhanced IDE Support: TypeScript offers better tooling in IDEs, including autocomplete, refactoring, and code navigation.
Backward Compatibility: It seamlessly integrates with existing JavaScript code, allowing for incremental adoption.

Comparing JavaScript, Node.js, and TypeScript

Choosing between JavaScript and TypeScript, and incorporating Node.js, depends on the project requirements:

JavaScript is ideal for small projects, rapid prototyping, and when a minimal learning curve is desired.
TypeScript excels in large codebases, team collaborations, and projects where long-term maintenance and scalability are critical.
Node.js is essential for server-side development, allowing JavaScript to be used for full-stack development and creating high-performance, scalable applications.

Applying TypeScript and Node.js in TeaBridge Project

Reflecting on my ongoing TeaBridge project—a web and mobile application for managing the tea industry in Sri Lanka—I realized that integrating TypeScript and using Node.js could be highly beneficial. TeaBridge connects tea leaf suppliers, factories, and buyers, requiring a robust and maintainable codebase.

Benefits for TeaBridge

Error Prevention: TypeScript’s static typing can help catch errors early, ensuring more reliable code.
Improved Collaboration: Enhanced tooling and clearer code documentation through type annotations can facilitate better team collaboration.
Easier Refactoring: Static types make refactoring safer and more efficient, helping to maintain and scale the project over time.
Server-Side Efficiency: Node.js provides a fast, scalable environment for handling server-side operations, improving overall application performance.

Integration Steps

1.Next.js (Web)

Set up a tsconfig.json file.
Rename .js files to .ts/.tsx.
Install TypeScript and type definitions

npm install --save-dev typescript @types/react @types/node

2.Expo (Mobile)

Initialize or convert the project to TypeScript.
Set up a tsconfig.json file.
Install TypeScript and type definitions

npm install --save-dev typescript @types/react @types/react-native

Conclusion

Today’s exploration of JavaScript, TypeScript, and Node.js provided valuable insights into how these technologies can enhance my development projects. Integrating TypeScript into TeaBridge, along with leveraging Node.js for server-side operations, promises to improve code quality, facilitate better collaboration, and ensure long-term maintainability. Embracing these powerful tools can significantly benefit both the web and mobile aspects of the project.

Exploring Cloud Computing: Insights from the Tech Talk with Chamith Kumarage

Kavishka Dinajara — Sat, 27 Jul 2024 18:13:51 +0000

Today, I had the privilege of attending an enlightening tech talk on cloud computing technologies, hosted by Chamith Kumarage, the co-founder of OPZQL, at NIBM Galle Campus. This session was part of the ongoing series of tech talks aimed at empowering minds with cutting-edge knowledge.

A Dive into Cloud Computing

Cloud computing has revolutionized the way we approach computing resources, making them more accessible, scalable, and efficient. During the session, Chamith Kumarage covered a wide range of topics, giving us a comprehensive overview of cloud computing and its various facets.

Key Areas Explored

1. Introduction to Cloud Computing

Understanding the basic concepts of cloud computing.
Differentiating between traditional computing and cloud computing.

2. Cloud Service Models

Infrastructure as a Service (IaaS): Providing virtualized computing resources over the internet.
Platform as a Service (PaaS): Offering hardware and software tools over the internet.
Software as a Service (SaaS): Delivering software applications over the internet.

Deployment Models:
- Public Cloud: Services offered over the public internet and available to anyone who wants to purchase them.
- Private Cloud: Dedicated environments reserved for a single organization.
- Hybrid Cloud: A combination of public and private clouds, allowing data and applications to be shared between them.
Benefits of Cloud Computing:
- Scalability
- Cost Efficiency
- Flexibility and Accessibility
- Disaster Recovery
- Automatic Updates
Challenges and Considerations:
- Security Concerns
- Compliance Issues
- Managing Cloud Costs
- Choosing the Right Cloud Provider

Why Cloud Computing is Fascinating

The session was not only informative but also inspiring. Chamith Kumarage shared real-world examples and case studies that illustrated the transformative power of cloud computing. From startups to large enterprises, the adoption of cloud technologies is driving innovation and efficiency across industries.

My Takeaways

Broad Understanding: I now have a better grasp of the fundamental concepts and models of cloud computing.
Practical Insights: The real-world examples provided practical insights into how cloud computing is applied in various scenarios.
Future Prospects: The session sparked my interest in exploring cloud computing further, especially in the context of developing scalable and efficient solutions.

In conclusion, today's tech talk was a valuable experience that broadened my understanding of cloud computing technologies. I look forward to diving deeper into this fascinating field and applying the knowledge gained to future projects.

If you have any thoughts or questions about cloud computing, feel free to leave a comment below. Let's continue the conversation!

Join the discussion: What are your thoughts on cloud computing? Have you had any experiences with it in your projects?

Unleashing the Power of ArToPay : A User's Perspective

Kavishka Dinajara — Mon, 25 Dec 2023 10:30:55 +0000

Introduction

In the fast-paced digital age, finding a platform that seamlessly integrates into our daily lives is a game-changer. ArToPay has emerged as a beacon of innovation, offering a versatile solution that not only simplifies tasks but enhances overall efficiency. In this article, I delve into my personal experiences with ArToPay and explore the myriad benefits that make it an indispensable tool.

User-Friendly Interface

One of the standout features of ArToPay is its intuitive and user-friendly interface. Navigating through the platform is a breeze, making it accessible to users of all levels of tech proficiency. The clean design and straightforward layout ensure that users can harness the platform's full potential without any steep learning curve.

Personal Efficiency Amplified

From the moment I integrated ArToPay into my daily routine, I noticed a significant boost in personal efficiency. The platform's diverse functionalities streamline various tasks, allowing me to manage my time more effectively. Whether it's organizing schedules, collaborating on projects, or accessing valuable resources, ArToPay has become my go-to companion for productivity.

Seamless Collaboration

Collaboration is the backbone of success in many endeavors, and ArToPay excels in facilitating seamless teamwork. The platform's collaborative features enable real-time sharing and editing, fostering a dynamic and interactive work environment. Communication channels are robust, ensuring that every team member stays in the loop, ultimately leading to more cohesive and successful projects.

Flexibility to Suit Your Needs

The beauty of ArToPay lies in its adaptability to diverse needs. Whether you're a professional managing complex projects or an individual seeking to streamline personal tasks, the platform offers customizable solutions. The ability to tailor ArToPay to my specific requirements has made it an indispensable asset in both my professional and personal life.

Security and Reliability

In an era where data security is paramount, ArToPay stands as a fortress, ensuring the confidentiality and integrity of user information. The platform's robust security measures and reliable infrastructure instill confidence, allowing users to focus on their tasks without worrying about potential vulnerabilities.

Conclusion

In conclusion, my journey with ArToPay has been nothing short of transformative. The platform's commitment to user-friendly design, innovative tools, and unwavering security has not only simplified my daily tasks but has elevated my overall productivity. As a user, I wholeheartedly endorse ArToPay as a game-changing solution that caters to the diverse needs of individuals and teams alike.

If you're ready to unlock a new realm of efficiency and collaboration, ArToPay is your answer. Embrace the future of productivity – I did, and the results speak for themselves.

Exploring the Power of APIs: My Journey at the Postman API101 Workshop

Kavishka Dinajara — Sun, 17 Dec 2023 05:07:02 +0000

The Postman API101 Workshop wasn't just informative; it was a revelation. As a student navigating the complexities of technology, this workshop emerged as a guiding light, imparting essential knowledge crucial for my academic and professional journey.

The workshop commenced with a comprehensive introduction to APIs—an elucidation that made the seemingly intricate concept surprisingly accessible. The facilitator's clarity in explaining the fundamental aspects of APIs and the significance of Postman as a tool was commendable. The 'what' and 'why' behind APIs suddenly became crystal clear.

Unveiling the myriad benefits of APIs felt like unlocking a treasure trove. Learning how APIs revolutionize businesses, facilitate seamless communication between systems, and pave the way for innovation left me in awe. Understanding how they enable us to access a vast array of services and information became a eureka moment.

The practical session, however, was the highlight. Engaging with the Joke API was not just fun but immensely insightful. Getting hands-on experience in manipulating data by adding, updating, and deleting jokes was empowering. Exploring the functionalities of GET, POST, PUT, and DELETE methods in real-time was a true 'aha' moment.

Reflecting on the workshop, its significance for my academic and professional growth cannot be overstated. The hands-on experience solidified theoretical concepts, making them tangible. It wasn't merely a session; it was an expedition into the world of APIs—an expedition that has equipped me with invaluable skills for the future.

This workshop was not just about learning; it was about experiencing the transformative power of technology firsthand. It's safe to say; it has etched a lasting impression on my journey toward becoming proficient in the tech landscape.