DEV Community: Gosu Code

Managing a scalable microservices API Gateway using KrakenD

Gosu Code — Thu, 16 Jul 2026 09:20:44 +0000

The fastest API Gateway in the market, ready to run on premises, cloud, or hybrid.

The gateway sits in front of your microservices to provide access control, security, throttling, analytics, and much more. KrakenD is not only a proxy but a Backend for Frontend that can aggregate and transform multiple calls simultaneously, avoiding network traffic and reducing bandwidth consumer to the end-user.

KrakenD can be set up in a single krakend.json file. A single, massive krakend.json with hardcoded backends is an anti-pattern. Pros treat gateway configurations like clean, modular code.

1. The Directory Structure

Instead of one file, we’re splitting gateway configuration by domain, environments, and general settings which keeps it dynamic and organized as well.

├── .env
├── .gitignore
├── docker-compose.yml
└── config/
    ├── krakend.tmpl
    ├── settings/
    │   ├── dev
    |   |   ├── hosts.json
    │   └── prod
    |       └── hosts.json
    └── endpoints/
        ├── products.tmpl
        └── users.tmpl

2. Step-by-Step Implementation

Step 1: Container Orchestration (docker-compose.yml)

Instruct KrakenD to enable Flexible Configuration (FC_ENABLE), declare the directory where your modular endpoint templates live (FC_TEMPLATES), and point to your environment variables (FC_SETTINGS).

services:
  gateway:
    container_name: api-gateway
    image: krakend:2.13.8
    ports:
      - "3000:3000"
    volumes:
      - ./config:/etc/krakend:ro
    environment:
      - FC_ENABLE=1
      - FC_TEMPLATES=/etc/krakend/endpoints
      - FC_SETTINGS=/etc/krakend/settings/dev
    command: ["run", "-c", "/etc/krakend/krakend.tmpl"]
    restart: unless-stopped

FC_ENABLE=1: Tells KrakenD to turn on the template engine.
FC_TEMPLATES: Points to the directory containing your modular template files (like your endpoints/ folder).
FC_SETTINGS: Points to the file or directory containing your environment variables (like hosts.json).

Step 2: Environment Settings (config/settings/dev/hosts.json)

Use this file to store microservice host URLs and environment-specific strings, keeping them out of your main routing logic.

{
  "hosts": {
    "product_service": "http://product-api:5001",
    "user_service": "http://user-api:5002"
  }
}

Step 3: Modular Endpoints (config/endpoints/users.tmpl)

Define template configurations using standard Go templating.

{
  "endpoint": "/api/auth/register",
  "method": "POST",
  "backend": [{
    "url_pattern": "/api/auth/register",
    "host": ["{{ .hosts.user_service }}"]
  }]
},
{
  "endpoint": "/api/auth/login",
  "method": "POST",
  "backend": [{
    "url_pattern": "/api/auth/login",
    "host": ["{{ .hosts.user_service }}"]
  }]
}

Notice how we reference "{{ .hosts.user_service }}"? At build time, KrakenD compiles this template and automatically swaps that placeholder with the URL from your environment settings file (hosts.json).

Q. what is this .tmpl file?

A: .tmpl (Template) file is a plain text blueprint containing static configuration mixed with dynamic placeholders (like {{ .hosts.user_service }}).
It leverages Go's templating engine to act as a flexible skeleton before the final configuration is compiled.

Example:

1. Template (users.tmpl):

"host": [ "{{ .hosts.user_service }}" ]

2. Variables (hosts.json):

{ 
  "product_service": "http://localhost:5001",
  "user_service": "http://localhost:5002"
}

3. What KrakenD actually runs in memory:

"host": [ "http://localhost:5002" ]

Q. "host": [ "{{ .hosts.user_service }}" ] how is it getting the user service url with that?

A: It works via KrakenD's Flexible Configuration(FC) engine during container startup. It executes in two quick steps:

The Flag: In your docker-compose.yml, you set FC_SETTINGS=/etc/krakend/settings/dev. This forces KrakenD to load your hosts.json file into memory as the core data dictionary.
The Evaluation: As KrakenD compiles the configuration, it encounters the template syntax {{ .hosts.user_service }}. The dot (.) represents the root of your loaded hosts.json file. It navigates down the keys: hosts → user_service, extracts the string "http://user-api:5002", and replaces the placeholder entirely before compiling the route.

Step 4: The Entrypoint (config/krakend.tmpl)

Tie everything together into the main skeleton. KrakenD will pull the files from your FC_TEMPLATES (defined in docker compose file) directory and compile them here.

{
  "version": 3,
  "port": 8080,
  "timeout": "3s",
  "endpoints": [
    {{ template "products.tmpl" . }},
    {{ template "users.tmpl" . }}
  ]
}

Now let's go a little bit further: extra_config

extra_config helps to enable and configure plugins, middleware, and extended features. It unlocks advanced capabilities such as security, rate limiting, logging and metrics.
krakend.tmpl

{
  "version": 3,
  "port": 8080,
  "timeout": "3s",
  "endpoints": [
    {{ template "products.tmpl" . }},
    {{ template "users.tmpl" . }}
  ],
  "extra_config": {
    "telemetry/logging": {
      "level": "INFO",
      "prefix": "[KRAKEND]",
      "stdout": true
    },
    "security/cors": {
      "allow_origins": ["*"],
      "allow_methods": ["GET", "POST", "PUT", "PATCH", "DELETE"],
      "allow_headers": ["Authorization", "Content-Type"]
    }
  }
}

In krakend.tmpl we are using it for logging and security(to handle cors).

user.tmpl

{
  "endpoint": "/api/auth/register",
  "method": "POST",
  "extra_config": {
    "qos/ratelimit/router": { "max_rate": 200, "capacity": 200, "every": "1s" }
  },
  "backend": [{
    "url_pattern": "/api/auth/register",
    "host": ["{{ .hosts.user_service }}"],
    "extra_config": {
      "qos/circuit-breaker": { "max_errors": 10, "interval": 60, "timeout": 30, "name": "cb-users-post-register", "log_status_change": true }
    }
  }]
},
{
  "endpoint": "/api/auth/login",
  "method": "POST",
  "extra_config": {
    "qos/ratelimit/router": { "max_rate": 200, "capacity": 200, "every": "1s" }
  },
  "backend": [{
    "url_pattern": "/api/auth/login",
    "host": ["{{ .hosts.user_service }}"],
    "extra_config": {
      "qos/circuit-breaker": { "max_errors": 10, "interval": 60, "timeout": 30, "name": "cb-users-post-login", "log_status_change": true }
    }
  }]
}

Here, we are using it for rate limiting and circuit-breaker.
rate limiting: 200 request per sec
circuit-breaker: Oh boy! it's on whole another level. Let's talk in detail below.

Circuit Breaker

It's job is to STOP KrakenD from sending requests to a failing service, giving that service time to recover and preventing a total system crash.

"extra_config": {
      "qos/circuit-breaker": { 
        "max_errors": 10, 
        "interval": 60, 
        "timeout": 30, 
        "name": "cb-users-post-login", 
        "log_status_change": true 
      }
}

How above specific setting works

Closed: Closed is a healthy state, it means circuit breaker is close and requests can pass normally.
Open: If KrakenD counts max_error(10 errors) within time interval(60s), it blocks all the requests to the backend server.
Half Open: After the 30-second timeout expires, the circuit breaker enters the Half-Open state. In that state, it allows to pass limited number of requests to test if the backend is actually stable. If the test passes, Circuit Breaker goes in Close state else goes in Open state.
Some unexplained configs in the circuit breaker
name: A friendly name to follow this circuit breaker's activity in the logs.
log_status_change: Whether to log the changes of state of this circuit breaker or not. Default to false.

More features provided by KrakenD

1. Data Manipulation & Aggregation: Merge multiple microservice responses into a single JSON object.
2. Authentication Offloading: Native JWT validation plugins allow the gateway to reject unauthorized requests at the edge before they even touch your internal networks.
3. Response Caching: In-memory or Redis caching options.
4. Comprehensive Metrics: Native integration with Prometheus, Jaeger, OpenTelemetry, and ELK stack for plug-and-play system visibility.

As I implement more features, I'll update this setup. How are you currently managing your API Gateway configurations? Let me know in the comments!

Have a nice day!

Difference between throw and throws

Gosu Code — Sun, 16 Feb 2025 13:09:10 +0000

Among throw and throws, the throws keyword is considered riskier, while throw is more straightforward.

throw keyword

The below picture shows how exception object is thrown by programmer to JVM

throw keywordSometimes we can create Exception object explicitly and we can handover to the JVM manually for this we have to use throw keyword.

throw new ArithmeticException("/ by zero");

throw : Manually passes the created exception object to the JVM.

new ArithmeticException("/ by zero"); : Creates exception object explicitly.

Example:-
In both cases below, the output remains the same:

In the first example, main method is responsible for creating exception object whereas in second example, programmer is responsible for creating an exception object.

These both program have the same output:

Exception in thread "main" java.lang.ArithmeticException: / by zero
        at ThrowNThrows.Test.main(Test.java:5)

But,

Why explicitly create exceptions?

Consider a banking system where a user attempts to withdraw more money than is available. The system returns an error like "Insufficient funds in your account." You don't have an exception like InsufficientFundException in JAVA predefined, so you have to create your own. Internally, this is handled using a custom exception:

withdraw(double amount){
  if(amount > balance){
      throw new InsufficientFundException();
  }
}

Just like in the above example, the best use of throw keyword is for user defined exceptions or customized exceptions. We'll discuss about customized exception later in the blog.

throw keyword is mostly used for customized exception.

Edge Cases for throw

CASE 1: Throwing an Exception Object

We can manually create an exception object and throw it. This works fine.

class Test1 {
  static ArithmeticException e = new ArithmeticException(); // creating exception object
  public static void main(String[] args) {
    throw e;
  }
}

Output:-

Exception in thread "main" java.lang.ArithmeticException
        at ThrowNThrows.Test1.<clinit>(Test1.java:5)
        at java.base/java.lang.Class.forName0(Native Method)

Problem: Throwing an Uninitialized Exception

If the exception object is not initialized, throw will result in a NullPointerException.

class Test2 {
  static ArithmeticException e;  // default object value null
  public static void main(String[] args) {
    throw e;  // e refers null
  }
}

Output:-

Exception in thread "main" java.lang.NullPointerException: Cannot throw exception because "ThrowNThrows.Test2.e" is null
        at ThrowNThrows.Test2.main(Test2.java:8)

CASE 2: Unreachable Code After throw

If an exception occurs at runtime, the next statement will not execute.

class Test {
  public static void main(String[] args) {
    System.out.println(10 / 0);
    System.out.println("Hello");  // will not be executed
  }
}

Output:-

Exception in thread "main" java.lang.ArithmeticException: / by zero
        at ThrowNThrows.CASE2.Test.main(Test.java:5)

Problem: Compiler Error for Unreachable Code

When using throw, the compiler detects unreachable code, leading to a compile-time error.

class Test {
  public static void main(String[] args) {
    throw new ArithmeticException("/ by zero");
    System.out.println("Hello");  // Unreachable code
  }
}

Note: After a throw statement, no further code can be executed unless handled with conditions like if-else.

CASE 3: Throwing Non-Throwable Objects

Only objects of Throwable type can be thrown. If we attempt to throw a normal Java object, it results in a compilation error.

class Test {
  public static void main(String[] args) {
    throw new Test(); // Incompatible types
  }
}

Output:-

ThrowNThrows/CASE3/Test.java:5: error: incompatible types: Test cannot be converted to Throwable
   throw new Test();
    ^
1 error

error: compilation failed
Solution: Extending Throwable

If the class extends RuntimeException, it can be thrown.

class Test2 extends RuntimeException {
  public static void main(String[] args) {
    throw new Test2();
  }
}

Output:-

Exception in thread "main" ThrowNThrows.CASE3.Test2
        at ThrowNThrows.CASE3.Test2.main(Test2.java:5)

throws keyword

The throws keyword is used when a method might throw a checked exception.
Example 1: Checked exception (FileNotFoundException)

import java.io.PrintWriter;

class WritingInFile {
  public static void main(String[] args) {
    PrintWriter pw = new PrintWriter("abc.txt");
    pw.println("Hello");
  }
}

Trying to access a file that may not be available will give an exception.

Output:

❯ javac WritingInFile.java
WritingInFile.java:5: error: unreported exception FileNotFoundException; must be caught or declared to be thrown 
    PrintWriter pw = new PrintWriter("abc.txt");
                     ^
1 error

Example 2:

class Sleep {
  public static void main(String[] args) {
    Thread.sleep(10000);  //sleeps for 10 seconds
  }
}

Whenever we call sleep method there may be a chance that main method may sleep, so it'll give an exception.
Output:

ThrowNThrows/Throws/Sleep.java:5: error: unreported exception InterruptedException; must be caught or declared to be thrown
    Thread.sleep(10000);
                ^
1 error
error: compilation failed

Ways to Handle Checked Exceptions

Way 1: Using try-catch(Recommended)

When you want to handle the exception on your own, you use try-catch .

class SleepProgram {
  public static void main(String[] args) {
    try{
      Thread.sleep(10000);  //sleeps for 10 seconds
    } catch(InterruptedException e){
      System.out.println("Exception handled");
    }
  }
}

Way 2: Using throws (Delegates responsibility to caller)

When you need to pass/delegate the responsibility of handling exception to the caller method, we can use throws keyword.

class SleepProgram{
  public static void main(String[] args) throws InterruptedException{
      Thread.sleep(10000);
  }
}

Here, the JVM handles the exception.
Key points:

throws keyword is only required for checked exception.
There is no impact of throws keyword in unchecked exception
throws keyword is required only to convince compiler
Uses of throws keyword doesn't prevent abnormal termination of the program.

Example: Exception Delegation
In this example, exceptions are delegated from methods to methods and finally to the JVM so we don't get any compile time error.

class Test {
  public static void main(String[] args) throws InterruptedException {
    doStuff();
  }

  public static void doStuff() throws InterruptedException {
    doMoreStuff();
  }

  public static void doMoreStuff() throws InterruptedException {
    Thread.sleep(5000);
  }
}

Try removing throws InterruptedException from different methods to observe compile-time errors.

Edge Cases for throws

CASE 1: Allowed for Methods & Constructors, Not for Classes

We can use throws keyword for methods and constructor but not for classes.

class Test{

  Test() throws Exception {
  }

  public void m1() throws Exception {
  }
}

CASE 2: throws Must Be Used with Throwable Types

class Test{
  public void m1() throws Test{   // ❌ Compile-time error
  }
}

Solution:

class Test extends RuntimeException{
  public void m1() throws Test{  // ✅ Valid
  }
}

The above code is valid because class Test is of type throwable . We can use throws keyword only for throwable types. If we try to use it for normal JAVA classes, then we will get compile time error saying incompatible types.

CASE 3: Checked vs. Unchecked Exceptions

Can you tell which will program will compile?

The answer is, First one… will not compile. Because Exception is a checked exception, so if we don't handle it compulsorily the program will not compile. Whereas, Error is unchecked exception so the second one will compile fine but we will get runtime exception.

CASE 4:

Take a look at these codes and try to answer which of these are gonna run. Hint: out of these five, three codes runs perfectly.

Did you guess the answer? The answer is 2, 4 and 5. 1 and 3 will not be able to run.

Inside a try block if there is no chance of rising an exception then we can't write catch block for that exception otherwise we will get compile time error saying, Exception xxx is never thrown in body of corresponding try statement. But this rule is applicable only for fully checked exception.

My 2025 Dev Plan

Gosu Code — Sun, 12 Jan 2025 15:10:09 +0000

For the first time in my life, I'm setting concrete goals for the year ahead. 2025 isn't just another year - it's going to be my year of intentional growth, both as a developer and as a person. I want to share my goals with you, and more importantly, document this journey of transformation.

1. Prioritizing Physical Well-being

Working remotely has its perks, but spending entire days in my room isn't one of them. My commitment? Three 30-minute walks per week.

2. Mastering Java

Last year, Java was just a plan that never materialized. Not this year. I'll commit to learning Java and its frameworks.

3. Collaborative Growth Through Pair Programming

They say two heads are better than one, and I'm putting that to the test. I'm committing to regular pair programming sessions with fellow developers. Not only will this improve my coding skills, but it'll also enhance my ability to communicate technical concepts effectively.

4. Building a Content Creation Habit

I'll write blogs about what I'm learning and doing every week or month. Writing is a good habit and can also be a source of income.

5. Create a Portfolio Website and Post Blogs on it

I'll build a new portfolio website using Next.js and Spring Boot. Although I'm not sure if Spring Boot can be hosted for free (if you know any options, please let me know in the comments).

6. Embracing the LeetCode Challenge

Let's be honest - I'm not a LeetCode expert (yet). But I'm committing to solving one problem every week. Some problems are genuinely fun, and I'm excited to see how my problem-solving skills evolve over time.

7. Ambitious Project Goals

Inspired by CodeCrafters, I'm taking on two significant projects:

Building an HTTPS server from scratch in Java
Creating an interpreter using Robert Nystrom's "Crafting Interpreters" as my guide

Progress Tracking

I'll be using:

Obsidian for blog post planning and goal tracking
Monthly reflection posts to assess progress and adjust course

I just remembered a quote from ThePrimeagen, video titled Cracking the Code | Open Sauce 2024:

"The race of big man think really big, the race of little man think about the process and how to be the most efficient. Dream big, accomplish big, you may fail but you accomplish much more than something small."

I'm dreaming big while focusing on the process. By December 2025, I hope to look back at this post with a sense of accomplishment. But even if I don't hit every target, I know I'll have grown more than if I'd never set these goals at all.

Have you set your development goals for 2025? What are you planning to achieve? Let's inspire each other in the comments below!

Flutter Hive: Mastering Offline Data Storage in Flutter

Gosu Code — Sun, 04 Feb 2024 06:08:15 +0000

Introduction

Flutter Hive is not just a database; it's your app's secret weapon for storing data faster than you can say "hot reload." Hive is a lightweight, NoSQL database designed for Flutter, and it's here to make your offline experience smoother than ever.

Unleashing the Hive Magic

📦 Boxes for Everything:

Hive organizes data neatly into 'boxes.' Think of them as magical containers where your app's data resides, ready to be accessed at the speed of thought.

🔍 Query Like a Pro:

Searching for data? Hive's got your back. Its querying capabilities make finding information a breeze, ensuring you get what you need when you need it.

Flutter + Hive = 💙

When Flutter and Hive join forces, your app becomes an offline superstar. No more worries about lost connections or slow data access - Hive's got your back, keeping your app running smoothly, online or offline.

Let's Dive In!

Ready to embrace the speed, simplicity, and Flutter-friendliness of Hive? Buckle up as we dive into the world of Flutter Hive - your ticket to lightning-fast offline storage! 🚀

1. Installing dependencies
Add these dependencies on your pubspec.yaml

dependencies:
  hive: ^2.2.3
  hive_flutter: ^1.1.0

dev_dependencies:
  hive_generator: ^1.1.3
  build_runner: ^2.1.11

Run the following command on your terminal to install dependencies.

flutter pub get

flutter pub add hive hive_flutter hive_generator build_runner

2. Initializing

main.dart

// Setting up Hive in Flutter
import 'package:hive/hive.dart';

void main() async {
  await Hive.initFlutter();
  // Hive is now ready to roll!
runApp(const MyApp());
}

3. Create Model
person_model.dart

import 'package:hive/hive.dart';

part 'person_model.g.dart';

@HiveType(typeId: 1) //typeId should be unique for each model
class PersonModel {
  @HiveField(0) //uinque id for each field
  String name;

  @HiveField(1)
  int age;

  @HiveField(2)
  List<Person> friends;
}

4. Generate TypeAdapter
After writing creating model, run the following command to generate TypeAdapter

dart run build_runner build

Add the generated TypeAdapter to the main.dart file.

import 'package:hive/hive.dart';

void main() async {
  await Hive.initFlutter();
  Hive.registerAdapter(PersonModelAdapter()); //add TypeAdapater
runApp(const MyApp());
}

5. Creating a CRUD service
Now we need to create some function to perform CRUD(create, read, update, delete) operation.

Let's create another file service.dart where we will keep our CRUD functions.

import 'package:your_app/models/person_model.dart';
import 'package:hive_flutter/hive_flutter.dart';

class Service {
final String  _boxName = "personBox";

Future<Box<PersonModel>> get _box async =>
      await Hive.openBox<PersonModel>(_boxName);

//create
  Future<void> addPerson(PersonModel personModel) async {
    var box = await _box;
    await box.add(personModel);
  }

//read
  Future<List<PersonModel>> getAllPerson() async {
    var box = await _box;
    return box.values.toList();
  }

//update
  Future<void> updateDeck(int index, PersonModel personModel) async { 
    var box = await _box;
    await box.putAt(index, personModel);
  }

//delete
  Future<void> deletePerson(int index) async {
    var box = await _box;
    await box.deleteAt(index);
  }
}

Now we can use these function to perform CRUD operation.

6. Implementing

Adding to the box

final PersonService _personService = PersonService();
TextEditingController nameController = TextEditingController();
TextEditingController ageController = TextEditingController();

//create a function to add the data
 void saveAndPop(BuildContext context) async{
    Navigator.pop(context);
    String name = nameController.text.trim();
    int age = nameController.text
    var person = CardModel(person: name, age: age);
    await _personService.addPerson(person);           //writing
  }

..// rest of your code

Column(
          children: [
            TextField(
              controller: nameController,
              decoration: const InputDecoration(
                hintText: 'Name'
              ),
            ),
            TextField(
              controller: ageController,
              decoration: const InputDecoration(
                hintText: 'Age'
              ),
            ),
            ElevatedButton(onPressed: (){
              saveAndPop(context);
            }, child: Text("Add")),
            ElevatedButton(onPressed: (){
              Navigator.pop(context);
            }, child: Text("Cancel")),
          ],
        ),

Getting from the box

//create an instance of the PersonService class.
final PersonService _personService = PersonService();

//open the box
Future<void> openBox() async {
  await Hive.openBox<PersonModel>('personBox');
}

@override
void initState() {    //calls when the widget is created
  super.initState();
  openBox();
}

@override
Widget build(BuildContext context) {
return Scaffold(
      body:
        //asynchronously build a widget tree
        FutureBuilder(
          future: _personService.getAllPerson(),
          builder: ( (context, snapshot) {
            if(snapshot.connectionState == ConnectionState.done){
              return 
           ValueListenableBuilder(
            //listens to changes in the hive box
            valueListenable: Hive.box<PersonModel>('personBox').listenable(), 
            builder: (context, box, _){
              //checking if the box is empty
              if(box.values.isEmpty){
              return const Center(
                child: Center(child: Text("No person available.")),
              );
              }
              //returns the data in list if there are any
              return ListView.builder(
                itemCount: box.values.length,
                itemBuilder: (context, index){
                  //retrieving PersonModel object from the box
                  var person = box.getAt(index);
                  return Column(
                           children: [
                              //displaying info
                              Text(person!.name),
                              Text(person!.age),
                              Text("Add Person"),
                            ],
                          );
                        }
                      );
                    });
                } else {
                 //if the future is not complete
                return Center(
                 child: CircularProgressIndicator()
              );
          }
      })
    )
  );
}

Deleting from the box

IconButton(
       onPressed: (){
         _cardService.deleteCard(index);
         }, icon: Icon(
        Icons.delete, 
       ))

Updating the values

final PersonService _personService = PersonService();

  TextEditingController nameController = TextEditingController();
  TextEditingController ageController = TextEditingController();

  //function to update
  void saveAndPop(BuildContext context) async{
    Navigator.pop(context);
    String name = nameController.text.trim();
    String age = ageController.text.trim();

    var card = PersonModel(name: name, age: age);
    await _personService.updatePerson(index,card);
  }

//Display the name and age before the change
  @override
  void initState(){
    super.initState();
    nameController.text = widget.name;
    ageController.text = widget.age;
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Column(
          children: [
            TextField(
              controller: nameController,
              decoration: const InputDecoration(
                hintText: 'Name'
              ),
            ),
            TextField(
              controller: ageController,
              decoration: const InputDecoration(
                hintText: 'Age'
              ),
            ),
            ElevatedButton(onPressed: (){
              saveAndPop(context);
            }, child: Text("Update")),
          ],
        ),
    );
  }

Thank you for investing your time in understanding how Flutter Hive can transform your applications. If you found value in this blog or if there's anything you think I missed, please don't hesitate to drop your thoughts in the comments below. Your feedback is immensely valuable, and I encourage you to share your insights, ask questions, or point out any mistakes you may have notices.

Mastering Symbolic Links: A Quick Guide

Gosu Code — Sun, 28 Jan 2024 08:12:09 +0000

Hey there tech enthusiasts! Let's get started with this sweet and short guide!

What Are Symbolic Links?

Symbolic links, or symlinks, are special files that act as pointers to other files or directories. They're like shortcuts, allowing you to access a file from a different location without duplicating it.

How to Create a Symbolic Link on Unix/Linux/macOS:

1. Open the Terminal:
Use your preferred terminal application.

2. Create a file at desired location
When creating a symbolic link, you typically point it to an existing file or directory. So, you should have the original file or directory already created before a symbolic link to it.

touch hello.txt

3. Navigate to the Desired Location:

cd /learn/file

4. Symlink creation command

ln -s /path/to/original/file_or_directory symlink_name

Example:

For file

ln -s /learn/file/hello.txt new.txt

It will create a new.txt file in the current directory you are in.

For folder

ln -s /learn/file newFolder

It will create a newFolder folder in the current directory.

5. Verify
Spot the symlink with the linked file or folder.

ls -l

output:

Folder

lrwxrwxrwx 1 user user 12 Jan 28 13:26 newFolder -> file

File

lrwxrwxrwx 1 user user 14 Jan 28 13:12 new.txt -> learn/hello.txt

6. To delete a symbolic link you can use the rm (remove) command:
Deleting a symbolic link is a straightforward process, and it involves removing the link file itself.

rm symlink_name

Example:

rm new.txt

And that's it! These little shortcuts are perfect for organizing files, creating quick access points, and streamlining your workflow. Experiment, have fun, and enjoy the power of symbolic links! 🚀
Your insights matter! If you spot any errors or have suggestions in my symbolic links guide, drop a comment - let's make it even better together!