## We're thrilled to announce the latest update for EazyMock, packed with exciting features designed to enhance your API mocking capabilities. Let's dive into the details of what's new and how these additions can elevate your development workflow.

## 1. **Roadmap for Next Feature**

One of the most requested features is now a reality! With EazyMock's new roadmap functionality, you can get a sneak peek into the upcoming features and improvements. Stay ahead of the game by planning your development tasks based on the roadmap, ensuring that you're always aligned with our commitment to continuous enhancement.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/fca72786-ca43-59a3-8828-94eac384b0c4.png)

## 2. **JSON with AI Generation**

Say goodbye to manual JSON crafting! EazyMock now integrates advanced AI capabilities to assist you in generating realistic JSON responses effortlessly. The AI analyzes your API structure and intelligently suggests data, making the process of creating mock responses faster, more accurate, and hassle-free.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/c79f36fa-7377-5a64-82e9-116da2552108)

## 3. **Clone Response Mock**

Streamline your workflow by duplicating existing mock responses. The new "Clone" feature allows you to replicate response mocks instantly. Whether you're creating variations or testing different scenarios, cloning responses saves you time and ensures consistency across your mocked APIs.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/defdaf3f-d87b-5db3-a4bb-4d03ae93a298)

## 4. **Set Throttling for Response API**

Simulate real-world conditions with precision. EazyMock introduces the ability to set response times for your APIs. Whether you need to test latency or evaluate performance under different time constraints, this feature empowers you to create a more realistic testing environment. Currently, we support 
- Fast 3G : with ~550ms latency
- Slow 3G : with ~2000ms latency
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/41225ae1-406d-555c-8cc1-a4e57dadeb8b)


## 5. **Enable/Disable Rule**

Take control of your mocking rules like never before. EazyMock now allows you to enable or disable specific rules at your convenience. This fine-grained control ensures that you can tailor your API responses with precision, enabling a more flexible and dynamic testing process.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/1d44de74-4b93-5d80-ba55-556ad23bb602)

Absolutely! Here's an expansion of the blog feature section, emphasizing user interaction and search functionalities:

---

## 6. **Blog Site Integration: Fostering Community Engagement**

In our commitment to providing a holistic experience, EazyMock introduces an immersive blog feature, creating a vibrant space for community interaction and knowledge sharing.

### 📚 **Dive into Knowledge Hub**

Explore a wealth of resources, tutorials, and insightful articles curated by our experts. The blog is your gateway to staying updated on the latest industry trends, best practices, and insider tips.
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/e0f3af43-329f-5371-b014-08975d884942.png)

### 🤝 **Community Interaction**

Elevate your learning experience by engaging with a community of like-minded developers. Connect, share experiences, and glean insights from fellow EazyMock users. The blog isn't just a resource; it's a dynamic community hub.

### 🌐 **Like, Comment, Share: Your Voice Matters**

Empower your fellow developers and express your thoughts! The blog allows users to interact with each other through likes, comments, and shares. Whether you resonate with a post or have valuable insights to share, your voice matters in shaping our collaborative ecosystem.

### 💬 **Fueling Conversations**

Every blog post is a conversation starter. Engage in discussions, seek clarification, or share your own experiences. The comment section is designed to foster meaningful conversations, turning each blog post into a dynamic forum for knowledge exchange.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/9a0afe93-345a-5547-a45c-dafe0900e770.png)

### 🔍 **Smart Search and Tag Filtering**

Navigating through a treasure trove of information has never been this seamless. Leverage our smart search functionality to find blogs by specific content, keywords, or topics. Want to explore a particular theme? Use tag filters to tailor your search and discover content that aligns with your interests.
- For Tag Filtering
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/21f0aacf-c15e-5989-9398-56641dbcd806.png)

- For Smart Search
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/2158fd1b-2df4-5c22-bf0d-64104a8126ae.png)

### 🌈 **Your Experience, Your EazyMock**

The blog feature isn't just an extension; it's an embodiment of our commitment to building a collaborative and supportive developer community. Explore, engage, and contribute to make EazyMock not just a tool but a shared space where knowledge thrives.

Ready to embark on a journey of shared insights and collaborative growth? Head to the EazyMock blog and be part of the conversation.

## How to Access the New Features

Getting started with these new features is simple:

1. Log in to your EazyMock account.
2. Navigate to App or Blogs pages and explore the "Features".
3. Enjoy a seamless experience with the latest updates at your fingertips.

These additions reflect our commitment to providing a robust and user-friendly platform for API mocking. We're excited to see how these features enhance your development workflow and bring your projects to new heights.

As always, your feedback is invaluable to us. If you have any suggestions, questions, or feature requests, don't hesitate to reach out to our support team. Thank you for choosing EazyMock – where API mocking meets simplicity and power!

Happy Mocking!

Unveiling a groundbreaking update for EazyMock – your go-to solution for seamless API mocking! Dive into the cutting-edge features that redefine the way you

Introducing EazyMock's Latest Features: Elevate Your Mocking Experience

Dat Tran

EazyMock is a free cross-platform desktop application that takes API mocking to the next level. EazyMock offers a fast and easy-to-use interface and gives you complete control over your mock APIs with advanced functionality like Project Management, Rules Management and Mock Management & Multiple Responses

This tutorial will show you how to install the desktop mocking application and set up your first mock API.

Let’s watch [EazyMock User Guide!](https://youtu.be/nqRcgtNfYiw)
[![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/d562fd62-bde4-558e-9cd9-7e1a97c050fd.png)](https://youtu.be/nqRcgtNfYiw)

To learn more about APIs and API mocking in general, head over to our [API guide](https://eazymock.net/app/user-guide?search=GettingStarted) or API [mocking guide](https://eazymock.net/app/user-guide?search=HowToUseEazyMock)


## Step 1. Install the application
EazyMock offers a powerful and accessible solution on our website platform, optimized for desktop usage. Explore our site today to access and experience the application firsthand.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/fd6a1495-e683-5039-8cba-f556ba86fcb5.png)

After navigate to application site, login may be required. You can login with Google/Github or create account with our service. Then, go inside and start setting up your first mock API.

## Step 2. Create your first mock API

Upon navigating to the application site, you may be prompted to log in. Enjoy the convenience of logging in with your Google or Github account, or seamlessly create a new account with our service. 
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/04e7b9e9-19bf-59dc-bf6a-bba0c8c7e364.png)

Once logged in, delve into the platform and kickstart the process of setting up your very first mock API.
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/67840bcd-705f-5f9f-b171-9ccc9f7d70db.png)

## Step 3. Create your first API route
The newly created mock API does not include a route on. You can create a new endpoint by clicking on the orange `+ Create New Mock` button at the top of the endpoint list:
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/12feedee-45e9-5540-bfd9-448fb3fe1edb.png)

## Step 4. API endpoint configuration
You can further customize your endpoint by adding a custom header and the following sample body (which makes use of EazyMock's templating system):

```
// Sample body
  [
  {{# repeat 5}}
  {
    "description": "Tutorial {{faker.paragraph}}",
    "date": "{{faker.date_time}}"
  }
  {{/ repeat}}
  ]
```

You can create a more complex configuration by adding multiple responses triggered by rules. Which explained specifically [here](https://eazymock.net/blogs/mastering-eazymock-advanced-rules-feature-guide-part-2-1DyJjtK82K)

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/695ffca2-25ef-58d8-9b65-d431e381396c.png)

## Step 5. Save and call your mock API
After saving your mock API, the final step is to initiate it. Simply click the 'Create Mock' button, and you'll obtain a mock API endpoint in your list. Retrieve the URL and begin making calls using other tools such as Postman or Insomnia.
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/01c10ce2-aa4b-5759-937d-8128575c6a3b.png)


##  Step 6. Learn more
Now that you know how to create a basic mock API, you can head over to the official documentation to explore the other functionalities like requests logging, partial API mocking with rules or create a response with AI

Use EazyMock to create your first mock API server in no time and generate fake realistic JSON body for your frontends.

Mastering EazyMock: Create your first mock API - Part 1

In the dynamic world of software development, testing and prototyping APIs play a crucial role. Mock APIs are invaluable tools that allow developers to simulate real API responses, ensuring a seamless integration process. In this guide, we'll explore the advanced rules feature of EazyMock, empowering users to create multiple responses with distinct rules for precise testing scenarios.

## Why Advanced Rules Matter

EazyMock are not just about simulating generic responses; they are about replicating the complexity of real-world APIs. With the advanced rules feature, users can define specific conditions for different parts of the API request, including the body, query parameters, headers, and path.

## Getting Started

### 1. Creating an EazyMock API

Begin by creating a new EazyMock API. Most platforms provide a user-friendly interface for this. Once your API is set up, you'll notice an option for advanced rules.
The process of creating a EazyMock API is outlined in this [blog](https://eazymock.net/blogs/mastering-eazymock-create-your-first-mock-api-part-1-yjO8JoTOJd).

### 2. Setting Rules for Body, Query, Header, and Path

In this sample we together find out how to use rules to create multi-response with a single API by EazyMock
```
1. POST API where user can post article and filter by region ----- Using body rules
2. GET API where user can get list TOP article by age ---- Using query rules
3. GET API where use can get article via pages number ---- Using path rules
```
#### Body Rules

Users have the flexibility to generate two distinct responses: one tailored for the "Asia region" and another for the "America region." This involves creating two unique request bodies to align with each response. 

| Asia | America | 
| -------- | -------- |
| ![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/51b6d5fb-54d2-586f-804e-9ba0bd151743.png)    | ![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/c2af7740-6d21-5db0-b5f2-fd10b046162a.png) |

Subsequently, when utilizing API testing tools, we can verify that the responses correspond appropriately to the distinct requests.

| Asia | America | 
| -------- | -------- |
|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/74497af3-fc8b-5003-bb9b-e06132342e34.png)  |  ![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/6aa2e020-e4f2-58b7-9a66-1ee41501dfd5.png)|

#### Query rules

By defining two query rules, users can obtain two distinct responses.
```
/?age=20 for 1 response 
/?age=30 for another response
```
- Mock Detail

| Age 20 | Age 30 | 
| -------- | -------- |
|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/7a19797c-c88a-5e95-94b0-103d8c3956d3.png)|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/6bab1f0e-32b1-50aa-b4e6-0658a2178b73.png)|

- By utilizing cURL copy, users have the option to select which response they want to run.

![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/f15e8ba8-eb94-5996-a492-245e09ebf40a.png)

- Response

| Age 20 | Age 30 | 
| -------- | -------- |
|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/cbd17c3d-0e45-573f-870b-37421ec665b2.png)|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/cb3dadfb-9b5d-5512-8cac-32152b8d2730.png)|

#### Header rules

- Header rules are analogous to the previously explained query rules.

#### Path rules

- Similar to the query and header rules, the configuration process in the rule tab is comparable. However, users need to adhere to a specific URL format to activate path rules. the URL for the path must be: 

```
/:path_id

example: 
GET /article/pages/:page_id
```
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/84691d6f-9f59-585f-8d1f-637b50f4ccd0.png)

Subsequently, users can obtain a response following the specified path format.

| Page 1 | Page 2 | 
| -------- | -------- |
|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/b53f016e-0dc2-5460-953b-1d8c7d88b143.png)|![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/d487f3a6-53b9-5457-96da-65bf59c18e42.png)|

In this guide, we'll explore the advanced rules feature of Mock APIs, empowering users to create multiple responses with distinct rules for precise testing

Mastering EazyMock: Advanced Rules Feature Guide - Part 2

Have you ever gone on a long hike only to realize that you‘ve been going in circles? That’s what it feels like developing an application without fully understanding how APIs work — cumbersome and aimless.

By coding against flawed mock data, developers get limited feedback and are unable to find problems or identify areas for improvement. Like a true navigator ensuring accuracy from point A to B, mocking is essential for testing your journey through development.

In this blog post, we'll discuss why API mocking is important for quick, quality feedback when building application — helping put those navigation worries behind you.

## What is API mocking?

API mocking involves creating an environment that mimics the behavior of an API. This space allows you to test and develop applications without relying on real data.

In a nutshell, API mocking is a way of creating realistic examples to simulate the expected response of an API. This involves creating “mock” versions of the various components that make up an API, such as data models and endpoints. You can then interact with them as if they were real APIs.

## The Benefits of API Mocking
API mocking can lead to improved quality of software development in a number of ways. Here are some key benefits.

### Faster Feedback
Let’s say you’re building an API with data that has yet to be created. Without mocking, you would need to wait until the real data has been required. This slows down the development of your application.

By providing developers with a realistic environment to test their code and test data, API mocking ensures that feedback is more accurate. You can more quickly find bugs, fix them, and optimize your systems. You’ll find yourself with more time instead of butting up against a deadline.

### Cost Savings
API mocking can save money in more than one way. The process allows developers to continue working on the project even if the actual API is not yet available or stable. This eliminates the need to wait for the API's availability or pay for third-party services during development.

API mocking also simulates a high load on the system without actually making requests to the real API. This eliminates the need for expensive load testing environments and resources, saving money on infrastructure costs.

Plus, mocking enables faster, parallel development and testing. Developers can work independently without waiting for the actual API to be ready, resulting in significant time and cost savings.

### Increased Security
Many teams work with sensitive data. Using real information before an API or app is fully ready leads to security risks. With API mocking, developers are working with fake data, reducing the risk of accessing sensitive information or leaking private data.

Further, mocking APIs allows developers to simulate various scenarios, including negative or malicious inputs, to identify potential vulnerabilities. By doing so, they can proactively fix security flaws or vulnerabilities before they become exploitable in the real system.

### Improved Reliability

API mocking allows developers to create specific testing scenarios to simulate different conditions. This includes edge cases, errors, and different input data. By having control over these scenarios, developers can validate the application's behavior and handle these situations in a reliable way.

Additionally, API mocking enables developers to accurately replicate the behavior of the real API. This helps identify potential performance bottlenecks, error handling issues, or compatibility problems and ensures that the application performs reliably under different conditions.

### Cross-Platform Compatibility
API mocking allows developers to simulate responses from different platforms or systems. This allows them to test the compatibility of their application with various APIs. This ensures that their app can handle the responses appropriately across multiple platforms.

## API Mocking Examples
API mocking is a powerful tool that can provide huge benefits to teams who are developing applications. Here are some of the most common examples of when a team might use mock APIs.

### Prototyping
API mocking can be used to quickly build and test a prototype of an application without having to rely on real APIs. This is especially useful for early-stage startups who need to develop quick prototypes in order to get funding or attract business partners.

### Automated Testing
Mocking allows developers to run tests on their code and get accurate feedback. You can then build an end product with fewer bugs and increased functionality.

API mocking can be used in automated testing to ensure that an application's performance is not affected by changes in the external APIs it relies on. This is especially beneficial for companies that have frequent updates to their products.

### Debugging
Using API mocking, developers can capture and replay specific API responses, allowing them to reproduce issues and debug them in a controlled environment. This makes it easier to analyze and identify the root causes of bugs, as they can repeatedly trigger the problematic scenario.

API mocks can also be used to quickly identify errors in an application without having to access real data.

### Integrating a Third-Party API
If you’re going to integrate a third-party API into your application, API mocking can help you at every step.

API mocking enables developers to start working on the integration even before the actual third-party API is available. By mocking the API endpoints and responses, developers can begin testing the integration logic without the finished third-party API.

With API mocking, developers can also decouple their application from the actual third-party API during testing. This eliminates the need to rely on the stability or rate limits of the external API. Development progress won’t be hindered by external factors.

Finally, API mocking provides a controlled environment where developers can verify that their application correctly interacts with the third-party API. Developers can simulate various responses without making actual requests to the live API, making it easier to isolate issues.

### Launching New Features
By creating mock versions of APIs, teams can ensure their code is functioning properly before pushing any changes live. Developers can identify and address potential issues in new features early. By simulating different scenarios, developers can quickly uncover and debug issues before the feature is released to users.

### Running Performance Tests
By running tests against virtual APIs, teams can identify performance issues and tweak their code in order to optimize the application. API mocking ensures that the responses are consistent, allowing you to replicate the same test scenarios repeatedly. This helps in comparing and analyzing test results more effectively.

## Top Tools for API Mocking
API mocking is an invaluable tool in the software development process. Here are some of the top tools for API mocking.

### 1. EazyMock
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/265fd2c9-70be-5dff-82de-20ee3c561c99.png)

[**EazyMock**](https://eazymock.net/) is a software designed to mock APIs.
With EazyMock, you can create and manage mock APIs to develop and test your application’s interaction with the APIs easily, quickly and efficiently. Under the hood, EazyMock also supports you create custom responses, define different scenarios so that you can test your application with the API comprehensively. This allows you to focus on building your application before having official APIs from the backend side.

**What we like:** EazyMock facilitates team collaboration. You can share mock servers with team members, collaborate on the APIs, and gather feedback directly within the tool. Moreover, you have the ability to reuse models and components, allowing you to effortlessly create high-quality APIs every time.

**Price**: Free

### 2. Mockoon
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/1feaae27-7c81-5ab6-b9a0-34ddf25ca7dc.png)
[**Mockoon**](https://mockoon.com/) is an open-source tool that makes it easy to create, configure and deploy mock APIs. It has a simple UI that allows users to quickly build their own mocks using predefined templates. You can run your mock application in a serverless, headless, or automated environment.Mockoon also allows you to serve your mock API over TLS with a custom certificate.

**What we like**: You don’t even need an account to start testing your application with Mocky. Their platform makes getting started a frictionless experience.

**Price**: Free

### 3. MockServer
![img](https://easymock-blog-dev-qovya.s3.ap-southeast-1.amazonaws.com/92bc9d9f-be50-5edf-bcd6-b755e4531901.png)
[**MockServer**](https://www.mock-server.com/) is an open-source tool that makes it easy to create and manage mock APIs. MockServer offers extensive request-matching capabilities, allowing you to define complex match criteria based on HTTP methods and query parameters. This enables you to precisely match and respond to different types of requests.

**What we like**: MockServer can act as a proxy server, allowing you to record real-world API interactions and create mocks based on observed patterns.

**Price**: Free.

## Getting Started with API MockingAPI 

Mocking is a valuable tool in the software development process. It can save time, money, and effort when building applications.There are many tools available for creating and managing mocks, each with its own features and capabilities. By choosing the right tool for your project, you can ensure that your API mocking process is as efficient and effective as possible.

Learn why API mocking is essential for quick and accurate feedback in application development. Discover the benefits, examples, and top tools for API mocking

API Mocking: The Complete Guide

[Part 1](https://eazymock.net/blogs/functional-programming-where-bugs-become-elegant-puzzles-sW3YH7gQbn)
[Part 2](https://eazymock.net/blogs/functional-programming-where-bugs-become-elegant-puzzles-part-2-yMpZavj0z5)

## Example 4: Fully Functional using `IBM/fp-go` package

The `IBM/fp-go` package provides a set of utilities to write fully functional code in Go. Let's see how we can use this package to implement the following example:

```go
type User struct {
	ID     string `json:"id"`
	Name   string `json:"name"`
	Phone  string `json:"phone"`
	RoleID int    `json:"role_id"`

	Role string `json:"role"`
}

type Role struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

const APIEnpoint = "https://api.eazymock.net/mock/5abdcf75-2345-4df6-ba62-1fb040f632eb/126/"

// getUsers fetches users from the API
func getUsers(endpoint string) ([]User, error) {
	resp, err := http.Get(endpoint + "users")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var users []User
	if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
		return nil, err
	}

	return users, nil
}

// getRoles fetches roles from the API
func getRoles(endpoint string) ([]Role, error) {
	resp, err := http.Get(endpoint + "roles")
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var roles []Role
	if err := json.NewDecoder(resp.Body).Decode(&roles); err != nil {
		return nil, err
	}

	return roles, nil
}

func main() {
	// Get users from API
	users, err := getUsers(APIEnpoint)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Get roles from API
	roles, err := getRoles(APIEnpoint)
	if err != nil {
		fmt.Println(err)
		return
	}

    // Add role to users
	roleMap := make(map[int]string)
	for _, role := range roles {
		roleMap[role.ID] = role.Name
	}

	var newUsers []User
	for _, user := range users {
		user.Role = roleMap[user.RoleID]
		newUsers = append(newUsers, user)
	}

	// print the result
	data, _ := json.MarshalIndent(newUsers, "", "  ")
	fmt.Println(string(data))
}
```

In this example, we fetch users and roles from an API, map roles to users, and print the result. I'm using [EazyMock](https://eazymock.net/) to simulate the API responses. [EazyMock](https://eazymock.net/) is a free online tool that allows you to mock APIs for testing and development purposes. It allows you to define API endpoints and responses, making it easy to test your code without relying on real APIs. It also provides AI-powered mock generation, making it easy to create mock APIs quickly.

Now, let's rewrite the same logic using the `IBM/fp-go` package:

```go
type User struct {
	ID     string `json:"id"`
	Name   string `json:"name"`
	Phone  string `json:"phone"`
	RoleID int    `json:"role_id"`

	Role string `json:"role"`
}

type Role struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

const APIEnpoint = "https://api.eazymock.net/mock/5abdcf75-2345-4df6-ba62-1fb040f632eb/126/"

func main() {
    // Create a new HTTP client
	client := H.MakeClient(http.DefaultClient)

    // 5-step pipeline to fetch users, roles, map roles to users, and print the result
	data := F.Pipe5(
        // Create a tuple of API endpoints
		T.MakeTuple2(APIEnpoint+"users", APIEnpoint+"roles"),
        // Make GET requests to fetch users and roles
		T.Map2(H.MakeGetRequest, H.MakeGetRequest),
        // Read JSON responses
		R.TraverseTuple2(
			H.ReadJSON[[]User](client),
			H.ReadJSON[[]Role](client),
		),
        // Chain to add roles to users
		R.Chain(func(t T.Tuple2[[]User, []Role]) R.ReaderIOEither[T.Tuple1[[]User]] {
			return F.Pipe2(
                // Create a map of role IDs to role names
				T.Of(getUserRoleMap(t.F2)),
                // Map roles to users
				T.Map1(func(roleMap map[int]string) []User {
					return addRoleToUsers(t.F1, roleMap)
				}),
				R.Of,
			)
		}),
        // Marshal the result to JSON
		R.Chain(func(t T.Tuple1[[]User]) R.ReaderIOEither[string] {
			data, _ := json.MarshalIndent(t.F1, "", "  ")
			return R.Of(string(data))
		}),
        // Print the result
		R.ChainFirstIOK(IO.Printf[string]("%v\n")),
	)

	result := data(context.Background())
	result()

}

// getUserRoleMap creates a map of role IDs to role names
func getUserRoleMap(roles []Role) map[int]string {
	roleMap := make(map[int]string)
	for _, role := range roles {
		roleMap[role.ID] = role.Name
	}
	return roleMap
}

// addRoleToUsers adds roles to users
func addRoleToUsers(users []User, roleMap map[int]string) []User {
	var newUsers []User
	for _, user := range users {
		user.Role = roleMap[user.RoleID]
		newUsers = append(newUsers, user)
	}
	return newUsers
}
```

The code may looks a bit complex at first, but it's more functional and composable. If you're familiar with the `fp-ts` library in TypeScript, you'll find the `IBM/fp-go` package quite similar. It provides a set of utilities to write fully functional code in Go, making it easier to manage side effects, error handling, and data transformations in a predictable and composable way.

[[Try it on Go playground](https://goplay.tools/snippet/nkxUS4oom3r)]

## Why Functional Programming?

Functional Programming offers several benefits that make it an attractive paradigm for software development:

- **Semantic Clarity**: FP emphasizes writing code that is more declarative and expressive, making it easier to understand and maintain.

- **Safer Programs**: By minimizing side effects and mutable state, FP reduces the likelihood of bugs and unintended consequences in your code.

- **Concise Code**: FP encourages writing code that is more declarative and expressive, leading to shorter, more readable programs.

- **Easier Debugging & Testing**: Pure functions and immutability make it easier to reason about and test your code, leading to more robust and reliable software.

- **Concurrency**: FP simplifies concurrent programming by eliminating shared mutable state, making it easier to write parallel and distributed systems.

By embracing Functional Programming principles, developers can write code that is more elegant, maintainable, and scalable, ultimately leading to more efficient and reliable software systems.

## Drawbacks

While Functional Programming offers many benefits, it also has some drawbacks that developers should be aware of:

- **Performance**: Functional Programming can sometimes lead to performance issues due to the overhead of creating new data structures and the lack of in-place updates.

- **Not 100% Functional**: It's challenging to write fully functional code in languages like Go, which are not purely functional. You may need to compromise on some functional principles to work within the language's constraints.

- **Idiomatic Go**: Functional Programming may not always align with idiomatic Go practices. Writing purely functional code in Go can sometimes feel unnatural or verbose.

- **Lack of Syntactic Sugar**: Functional Programming can be more verbose than imperative programming, especially in languages like Go that lack syntactic sugar for functional constructs.

## When to Use Functional Programming?

Functional Programming is well-suited for a wide range of scenarios, including:

- **When Performance is Not Critical**: If performance is not a primary concern, Functional Programming can be an excellent choice for writing clear, maintainable, and reliable code.

- **Whenever Possible**: Functional Programming can be used whenever possible, even in languages like Go that are not purely functional. Leveraging functional constructs can lead to more elegant and efficient code.

- **Utilize Libraries**: Functional Programming libraries and utilities can help you write more functional code in languages like Go. By leveraging existing tools and libraries, you can embrace FP principles without reinventing the wheel. Some popular libraries for Go include `IBM/fp-go`, `samber/lo`, and `samber/mo`.

## Misconceptions

Functional Programming is often misunderstood due to several misconceptions:

- **Syntactic Sugar**: Functional Programming is sometimes dismissed as mere syntactic sugar or a coding style. In reality, FP is a paradigm that fundamentally alters how we approach software development.

- **Complicated**: Functional Programming is often perceived as complex and difficult to learn. While it may require a shift in mindset, the core concepts of FP are intuitive and can lead to more elegant and maintainable code.

- **Never Side-Effects**: Functional Programming does not eliminate side effects entirely. Instead, it minimizes side effects and isolates them to specific parts of the codebase, making it easier to reason about and manage.

- **Academic**: Functional Programming is sometimes seen as an academic pursuit with limited real-world applications. In reality, FP is widely used in industry and can lead to more efficient, reliable, and scalable software systems.

## Conclusion

Functional Programming is more than just a coding style; it's a paradigm shift that transforms the way we think about writing software. By embracing FP principles such as pure functions, immutability, recursion, higher-order functions, and monads, developers can write elegant, efficient, and maintainable code. While FP may not be a one-size-fits-all solution, it offers many benefits that make it an attractive choice for a wide range of scenarios. By understanding the core concepts of Functional Programming and leveraging the right tools and libraries, developers can unlock the full potential of FP and embark on a journey to solve programming puzzles with elegance and efficiency.

The IBM/fp-go package provides a set of utilities to write fully functional code in Go. Let's see how we can use this package.

Functional Programming: Where Bugs Become Elegant Puzzles (Part 3)

Hung Vo

In the [previous article](https://eazymock.net/blogs/functional-programming-where-bugs-become-elegant-puzzles-sW3YH7gQbn), we delved into the core concepts of Functional Programming (FP) and how they can transform the way we write software. Now, let’s dive deeper into some practical use-cases in Go, showcasing the elegance and efficiency of FP in action.

First up, let’s take a look at some examples.

## Example 1: Mapping and Filtering

Given a list of users, we want to filter all male users. Here’s how we can achieve this in the imperative style by using a traditional loop:

```go
type User struct {
   ID     int
   Name   string
   Gender string
   Age    int
}

users := []User{
 {1, "Alice", "F", 25},
 {2, "Bob", "M", 30},
 {3, "Charlie", "M", 35},
 {4, "Diana", "F", 40},
}

// Filter users by gender
var maleUsers []User
for _, user := range users {
   if user.Gender == "M" {
       maleUsers = append(maleUsers, user)
   }
}

fmt.Println(maleUsers) // [{2 Bob M 30} {3 Charlie M 35}]
```

In this example, we iterate over the list of users and filter. If we want to filter by female users or ages, we would need to find and change the condition in the loop. This approach can be error-prone and challenging to maintain.

Let’s rewrite the same logic using FP principles. First, we define a `filter` function that takes a `predicate` function as an argument:

```go
func filter(users []User, predicate func(User) bool) []User {
   var filteredUsers []User
   for _, user := range users {
       if predicate(user) {
           filteredUsers = append(filteredUsers, user)
       }
   }
   return filteredUsers
}
```

Now, we can define a predicate function to filter users. In this case, we want to filter all male users:

```go
func isMale(user User) bool {
   return user.Gender == "M"
}
```

Finally, we apply the `filter` function with the `isMale` predicate:

```go
maleUsers := filter(users, isMale)
fmt.Println(maleUsers) // [{2 Bob M 30} {3 Charlie M 35}]
```

If we want to filter by felame users, we can define a new predicate function and reuse the `filter` function:

```go
func isFemale(user User) bool {
   return user.Gender == "F"
}

femaleUsers := filter(users, isFemale)
fmt.Println(femaleUsers) // [{1 Alice F 25} {4 Diana F 40}]
```

We can take a step further and generalize predicate of gender by using higher-order functions:

```go
func gender(g string) func(User) bool {
   return func(user User) bool {
       return user.Gender == g
   }
}
```

Now, we can create specific predicates

```go
maleUsers := filter(users, gender("M"))
femaleUsers := filter(users, gender("F"))
```

In the real world, we rarely define a `filter` function from scratch. Instead, we can use functions like `lo.Filter` and `lo.Map` from the `samber/lo` package:

```go
import "github.com/samber/lo"

func gender(g string) func(User, int) bool {
   return func(user User, _ int) bool {
       return user.Gender == g
   }
}

func incAge(user User, _ int) User {
   user.Age++
   return user
}

femaleUsers := lo.Map(lo.Filter(users, gender("F")), incAge)

fmt.Println(femaleUsers) // [{1 Alice F 26} {4 Diana F 41}]
```

[[Try it on Go playground](https://goplay.tools/snippet/8tL4r4RYWK-)]

## Example 2: Monads and Error Handling

Monads are a powerful concept in FP that can help manage side effects and error handling in a predictable and composable way. Let’s explore how we can use monads to handle errors gracefully in Go. Given a function that divides numbers:

```go
func compute(a, b, c, d int) (int, error) {
   if a == 0 {
       return 0, fmt.Errorf("division by zero")
   }
   x := b / a
   if x == 0 {
       return 0, fmt.Errorf("division by zero")
   }
   y := c / x
   if y == 0 {
       return 0, fmt.Errorf("division by zero")
   }

   return d / y, nil
}

func main() {
   result, err := compute(2, 10, 5, 2)
   if err != nil {
       fmt.Println(err) // Handle potential errors
       return
   }
   fmt.Println(result) // Output: 2
}
```

In the imperative style, we would need to check for errors at each step and handle them accordingly. This can lead to verbose and error-prone code. Let's see how we can rewrite this logic using monads. We will use the `mo.Result` monad from the `samber/mo` package:

```go
import "github.com/samber/mo"

func divide(a int) func(int) mo.Result[int] {
   return func(b int) mo.Result[int] {
       if b == 0 {
           return mo.Err[int](fmt.Errorf("division by zero"))
       }
       return mo.Ok(a / b)
   }
}

func compute(a, b, c, d int) mo.Result[int] {
   return mo.Ok(a).
       FlatMap(divide(b)).
       FlatMap(divide(c)).
       FlatMap(divide(d))
}

func main() {
   result := compute(2, 10, 5, 2)
   // Handle result
   if !result.IsOk() {
       fmt.Println(result.Error()) // Handle potential errors
   }

    fmt.Println(result.MustGet()) // Output: 2
}
```

As you can see, using monads simplifies error handling and makes the code more concise and readable. By leveraging monads, we can manage side effects and errors in a predictable and composable way, leading to more robust and maintainable code.

[[Try it on Go playground](https://goplay.tools/snippet/EuCoojBNBG0)]

## Example 3: Server Options

Given the following server configuration:

```go
type Server struct {
   opts options
}

type options struct {
   maxConn       int
   transportType string
   timeout       int
}
```

Let's see how we can create server options using functional options:

```go
type ServerOption func(options) options

func MaxConn(n int) ServerOption {
   return func(o options) options {
       o.maxConn = n
       return o
   }
}

func Timeout(t int) ServerOption {
   return func(o options) options {
       o.timeout = t
       return o
   }
}
```

We're defining `ServerOption` as a function that takes `options` and returns `options`. This allows us to create different server options by composing these functions. Let's write our server constructor:

```go
func NewServer(opts ...ServerOption) *Server {
   var o options
   for _, opt := range opts {
       o = opt(o)
   }
   return &Server{opts: o}
}
```

The `NewServer` function takes a variadic list of `ServerOption` functions, applies them to the default options, and returns a new `Server` instance. Here's how we can create a server with custom options:

```go
server := NewServer(MaxConn(100), Timeout(30))
...
// &{opts:{maxConn:100 transportType: timeout:30}}
```

If we want to add more options in the future, we can define new `ServerOption` functions and compose them as needed. This approach allows us to create flexible and extensible APIs without cluttering the constructor with numerous parameters. For example, we can add a `TransportType` option:

```go
func TransportType(t string) ServerOption {
   return func(o options) options {
       o.transportType = t
       return o
   }
}

server := NewServer(MaxConn(100), Timeout(30), TransportType("tcp"))
...
// &{opts:{maxConn:100 transportType:tcp timeout:30}}
```

[[Try it on Go playground](https://goplay.tools/snippet/o5qXnhECpMO)]

We have explored how functional programming concepts can be applied in real-world scenarios using Go. By leveraging pure functions, immutability, recursion, higher-order functions, and monads, developers can write elegant, efficient, and maintainable code. In the next article, we will try to implement a fully functional code using the `IBM/fp-go` package.

Let’s dive deeper into some practical use-cases in Go, showcasing the elegance and efficiency of FP in action.

Functional Programming: Where Bugs Become Elegant Puzzles (Part 2)

## What is Functional Programming?

### Programming Paradigms

#### Structured Programming

In structured programming, the state is external to the code. Programs are structured in a way that separates data and behavior.

#### Object-Oriented Programming (OOP)

OOP integrates state into objects. Objects encapsulate both data and behavior, leading to a modular and scalable approach to software design.

#### Functional Programming (FP)

In FP, the concept of state is minimized or even eliminated. Functional programmers strive to work without relying on traditional state concepts, focusing instead on composing functions to achieve desired outcomes.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/t1hRc2VLXbDKaCAmhDa4V.webp)
*[Coderized - The purest coding style, where bugs are near impossible](https://www.youtube.com/watch?v=HlgG395PQWw&t=80s)*

### Imperative vs. Declarative

#### Imperative

Imperative programs specify a sequence of steps on how to achieve a result. They focus on the execution order, detailing each action to be performed.

#### Declarative

Declarative programs express the desired outcome or what to achieve. They emphasize the logic and relationships between components rather than the step-by-step execution.

#### Examples

- In imperative style

```javascript
let sumEvenNumbers = 0;
for (let i = 0; i < 100; i++) {
	if (i % 2 !== 0) {
		sumEvenNumbers += i;
	}
}
```

- In declarative style (using FP)

```javascript
const sumEvenNumbers = [...Array(100).keys()]
	.filter((x) => x % 2)
	.reduce((a, b) => a + b);
```

Functional Programming encourages a shift in mindset, promoting the composition of pure functions and emphasizing immutability. By embracing FP principles, developers can write code that is more concise, maintainable, and easier to reason about, ultimately leading to more robust and scalable software systems.

## Key concepts

Functional Programming (FP) is more than just a coding style; it’s a paradigm shift that transforms the way we think about writing software. Let’s delve into the core concepts of FP to unlock its potential:

### Pure Functions

#### What are they?

Pure functions are the backbone of FP. They have two main characteristics:

- **Deterministic**: Pure functions always produce the same output for a given set of inputs, making them predictable and reliable.
- **Side-Effect Free**: They do not modify external state or perform I/O operations, ensuring that their behavior is isolated and consistent.

``` go
// ❌ causing side effects
func datediff(date1 time.Time) time.Duration {
   return date1.Sub(time.Now())
}

// ✅ Pure Function
func datediff(date1 time.Time, date2 time.Time) time.Duration {
   return date1.Sub(date2)
}

// ❌ modifying argument
func incAge(user *User) {
   user.Age++
}

// ❌ causing side effects
func process() {
   fmt.Println("Processing...")
}

// ✅ Pure Function
const Pi = 3.14159
func circleArea(r float64) float64 {
   return Pi * r * r
}
```

#### Why are they important?

- **Predictability**: Pure functions make code easier to reason about since their behavior is solely determined by their inputs.

- **Testability**: Testing pure functions is straightforward, as there are no external dependencies to set up or manage.

### Immutability

#### What is it?

In FP, data structures are immutable, meaning they cannot be changed after creation. Instead, new versions of data structures are created to represent changes.

```go
// ❌ Mutable data
var john User = User{1, "John"}
john.Name = "Doe"

// ✅ Immutable data
func (u User) changeUserName(name string) User {
   u.Name = name
   return u
}

var john User = User{1, "John"}
doe := john.changeUserName("Doe")
```

#### Why does it matter?

- **Safety**: Immutable data structures prevent accidental data corruption or unintended side effects.
- **Concurrency**: Immutability simplifies concurrent programming by eliminating the need for locks or synchronization mechanisms.

### Recursion

#### How does it work?

Recursion is a fundamental technique where a function calls itself to solve a problem by breaking it down into smaller, self-similar subproblems.

```go
func fact(n int) int {
   if n == 0 {
       return 1
   }
   return n * fact(n-1)
}
```

#### Tail Recursion

A special type of recursion where the recursive call is the very last thing the function does before returning a result.

Optimization (TCO): With Tail Call Optimization, a smart compiler can turn tail recursion into a loop-like structure under the hood, saving stack space and making it more efficient.

Go and TCO: Unfortunately, Go does not guarantee Tail Call Optimization. This means heavily recursive code could run into stack overflow issues if you aren't careful.

```go
// Tail-recursive version
func fact(n int) int {
   return tailFact(n, 1)
}

func tailFact(n, a int) int {
   if n == 0 {
       return a
   }
   return tailFact(n-1, n*a)
}
```

#### Why use it?

- **Simplicity**: Recursion simplifies code by expressing complex problems in terms of simpler ones.
- **Expressiveness**: Recursive solutions often mirror the problem's structure more naturally, leading to clearer and more concise code.

### First-Class Functions and Higher-Order Functions

#### What are they?

- **First-Class Functions**: Functions are treated as first-class citizens, meaning they can be passed as arguments, returned from other functions, and assigned to variables.
- **Higher-Order Functions**: Functions that either take other functions as arguments or return new functions.

```go
// greeterFunc is getting passed as an argument
func processGreeting(greeterFunc func(string) string, name string) string {
   return greeterFunc(name)
}

fmt.Println(processGreeting(greet, "Alice")) // Output: Hello, Alice!

// createGreeter is returning a function
func createGreeter(greeting string) func(string) string {
   return func(name string) string {
       return greeting + ", " + name + "!"
   }
}

// friendlyGreeter is a function returned by createGreeter
friendlyGreeter := createGreeter("Hi")
fmt.Println(friendlyGreeter("Bob")) // Output: Hi, Bob!
```

#### How do they empower FP?

- **Abstraction**: First-class and higher-order functions enable powerful abstractions, allowing developers to write more generic and reusable code.
- **Flexibility**: They provide flexibility in designing algorithms and composing complex behaviors from simpler building blocks.

### Closure and Currying

#### What are they?

- **Closure**: A function that retains access to variables from its lexical scope even after the scope has exited.
- **Currying**: The process of transforming a function that takes multiple arguments into a series of functions, each taking a single argument.

```go
// The outer function createGreeter returns the inner function
func createGreeter(greeting string) func(string) string {
   return func(name string) string {
       return greeting + ", " + name + "!"
   }
}

friendlyGreeter := createGreeter("Hi")

// Even after createGreeter has exited, the inner function retains access to the greeting variable, in this case, "Hi"
fmt.Println(friendlyGreeter("Bob")) // Output: Hi, Bob!
```

#### Why are they useful?

- **Encapsulation**: Closures encapsulate state within functions, leading to modular and maintainable code.
- **Partial Application**: Currying facilitates partial function application, allowing for more flexible and composable APIs.

### Other concepts

- **Lambda Expressions**: Short, unnamed functions you can define and use on the fly. (e.g., in JavaScript: (x, y) => x + y)
- **Monads**: A way to structure computations that might involve side effects (like errors or missing values) safely and predictably.
- **Lazy Evaluation**: Calculating values only when they're needed, potentially saving time and resources.
- **Functors**: Let you apply functions to elements inside data structures, like mapping over a list to double each number.
- **Homomorphism**: A structure-preserving function. If you turn a list of numbers into a list of their string equivalents, that's a homomorphism.
- **Higher-Kinded Types**: Types that can take other types as arguments, letting you make super-general abstractions. These get complex quickly!

Understanding these key concepts is crucial for harnessing the power of Functional Programming. By embracing pure functions, immutability, recursion, higher-order functions, and closures, developers can write code that is not only elegant and concise but also robust, scalable, and maintainable. Unlock the potential of Functional Programming and embark on a journey to solve programming puzzles with elegance and efficiency.

In next part, we'll explorer some practical use-cases of functional programming in Go.

Functional Programming (FP) is more than just a coding style; it's a paradigm that fundamentally alters how we approach software development. Let's explore!

Functional Programming: Where Bugs Become Elegant Puzzles

# 1. Tanstack là gì 
Tanstack là một bộ công cụ phát triển phần mềm mã nguồn mở. Nó cung cấp một loạt các giải pháp giúp các nhà phát triển có thể xây dựng các ứng dụng web và di động một cách hiệu quả, nhanh chóng và mạnh mẽ. Tanstack bao gồm nhiều công cụ và thư viện khác nhau, tất cả đều được thiết kế để tối ưu hóa quy trình phát triển, từ việc quản lý trạng thái ứng dụng, xử lý dữ liệu, đến việc tạo UI.
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/L8ZsBSp5wqT2yhmH-zF8c.webp)

Tanstack hiện nay đang phát triển và sử dụng rộng rãi với các thư viện nổi tiếng như: 

- **Tanstack Query**: Được biết đến như là 1 thư viện hỗ trợ cho việc fetching dữ liệu với các tính năng cực cháy ( **fetching, caching, synchronizing and updating server state** ).
- **Tanstack Table**: Là 1 thư viện **Headless UI**. Nó cung cấp rất nhiều tính năng, bao gồm việc sắp xếp, lọc, phân trang, và nhiều hơn nữa. Tanstack Table thích hợp cho cả các ứng dụng lớn và nhỏ, và có thể được tùy chỉnh để phù hợp với nhiều yêu cầu khác nhau.
- **Tanstack Router**: Là 1 thư viện về routing mới nổi gần đây, ngoài những tính năng cơ bản của 1 thư viện routing thì nó còn được biết đến với các chức năng độc đáo khác ( type-safe, file-base routing, context routing và validation param,....).
- **Tanstack Virtual**: Cũng tương tự như **Tanstack Table**, là 1 thư viện **Headless UI** được sinh ra để hỗ trợ người dùng trong việc render các phần tử 1 ở cây DOM 1 cách "***ảo***" hơn.
......

# 2. Tại sao nói Tanstack là đấng cứu thế mới 
Cùng đặt lên bàn cân giữa Tanstack và những thư viện khác xem nào
## 1. Tanstack Query vs RTK Query 
Nếu bạn từng làm việc với cả 2 thư viện này, thì cảm nhận đầu tiên của bạn chắc chắn sẽ là: 

>  Sao Tanstack Query lại dễ sử dụng và setup như vậy

> Công nhận khi sử dụng Tanstack Query, số lượng **LOC (line of code)** giảm đi hẳn

Có một sự thật không thể chối cãi về **RTK Query** đó là nó được viết ra để cùng với **Redux Toolkit** trở thành 1 công cụ không những hỗ trợ data-fetching mà còn là quản lý state. Nhưng cũng vì thế RTK Query cũng bị hạn chế, nó không thể sử dụng 1 cách đơn lẻ, từ đó kéo theo rất nhiều hạn chế về **bundle size cũng như là việc khó khăn trong setup và sử dụng**.

Một mặt khác, Tanstack Query là 1 công cụ có thể hoạt động riêng lẻ mà không phụ thuộc vào bất kì thư viện nào nữa. Việc setup và sử dụng cũng dễ dàng hơn rất nhiều nếu so với đối thủ. Ngoài ra còn các tính năng khác như hỗ trợ **Infinite Query, Devtool** ... [(link tham khảo)](https://tanstack.com/query/latest/docs/framework/react/comparison#comparison-or-react-query-vs-swr-vs-apollo-vs-rtk-query-vs-react-router)

### Vấn đề thực tế: 

Tôi có 1 dự án được setup sử dụng **RTK Query** và **Nextjs** lúc ban đầu để hỗ trợ việc fetch dữ liệu ở phía server. Mọi chuyện cũng sẽ không có gì xảy ra cho đến khi "***kỉ niệm ùa về***", dự án của chúng tôi gặp vấn đề ở nghiêm trọng ở server, **Memory leak** . Nguyên nhân ban đầu được xác định là do ở RTK Query khi muốn fetch data ở phía server cần phải sử dụng thêm 1 thư viện thứ 3 mà chính Redux recommend: **next-redux-wrapper**, chính thư viện này cùng với việc bản thân **RTK Query** không thể clear được Memory dẫn đến Memory ở phía server khi tăng lên đến 1 mức mà [chúng tôi không thể nào tìm cách để clear ngay được](https://github.com/reduxjs/redux-toolkit/issues/3988#issuecomment-1929552259)
[link tham khảo](https://github.com/reduxjs/redux-toolkit/issues/4359)
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/xfZiMoT3fqm2BJ2epC-ax.webp)

Lúc này đấng cứu thế xuất hiện, chúng tôi đổi hướng sang sử dụng Tanstack Query với các tính năng gần như là tương tự nhưng được hỗ trợ việc clear memory ở phía server [(link tham khảo)](https://tanstack.com/query/latest/docs/framework/react/guides/ssr#high-memory-consumption-on-server)
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/BgidRq-cmEQVVGteBirBG.webp)

## 2. Tanstack Router vs React Router
React Router là 1 thư viện đã quá nổi tiếng với người dùng React, ngoài việc đã phát triển tới [phiên bản thứ 6](https://reactrouter.com/en/main) với nhiều tính năng thì còn có cộng đồng người dùng lớn. 
Nhưng lúc này có 1 chú ngựa ô đã và đang tiến vào đường đua này, đó là [Tanstack Router](https://tanstack.com/router/latest/docs/framework/react/overview), được giới thiệu với phiên bản v1 gần đây nhưng nhận được sự chú ý khá lớn của cộng đồng với nhiều ưu điểm và hứa hẹn đáng móng chờ sẽ có thể thay thế được người anh tiền nhiệm:
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/HMG7CnE6o1gyv6rIB7M4k.webp)

### Ưu điểm nếu đem ra so sánh: 
Ngoài các tính năng gần như giống với người đàn anh React Router thì Tanstack Router còn có các tính năng đáng chú ý như: 

- **Type safe 100%** : Đây có vẻ là tính năng khá hay ho mà Tanstack Router giới thiệu, nó cho phép người dùng chọn có thể Typesafe navigation
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/L4qR4-aslWYcEBt-7mAEo.webp)
- **File-base navigate**: Nếu ai đã dùng các framework như **Nextjs** hay **Remix** thì tính năng này cũng không còn quá xa lạ, đây là tính năng cho phép bạn có thể tạo ra các Route của mình 1 cách tự động khi tạo file mà không cần phải làm thủ công.
- **Validate Param**: Là 1 tính năng khá mới của Tanstack Router. Nó cho phép bạn có thể validate được các param mà bạn nhận xuống từ url trước khi đem xuống và sử dụng, từ đó nâng cao được tính bảo mật và chất lượng code
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/y8VJEKtZpySNWeSH6cKdo.webp)
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/NEmQLu5HGCm4HPdxhgorU.webp)
- **Authentication (Protected Router)**: Tanstack Router giới thiệu phương thức ```beforeLoad```, với  ```beforeLoad``` bạn có thể thực hiện việc Authenticate trước khi render ra component nếu so với trước kia bạn phải tạo 1 ```HOC Component``` và dùng nó để bọc các trang mà bạn cần Authenticate lại
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/yhxUdRzyR1S-_NF3FNwUN.webp)

## Tổng Kết: 
Tanstack đã cho ra đời nhiều thư viện và vẫn đang trong quá trình phát triển. Những thư viện này được cộng đồng đánh giá cao và cho thấy được những dấu hiệu tích cực. Ngoài các thư viện nêu trên thì Tanstack vẫn đang phát triển nhiều thư viện khác với mã nguồn mở. Hãy cùng chờ đợi xem các thư viện này liệu có thể thay đổi được cuộc chơi giữa nhiều ông lớn như ở hiện tại không.

Tanstack, Đấng Cứu Thế Mới (Phần 1)

Kiet Do

# Introduction

The terms Clean architecture and Hexagonal Architecture are very popular nowadays, but people blindly implement the same structure and solution in the OOP languages like Java and C# everywhere. This eventually led to projects that were hard to maintain, code that unreadable, and the community refused to use these Java-like solution. 

In this blog post, let's find the answer from a different angle. We'll delve into the fundamentals, advantages, and implement application using Hexagonal Architecture with idiomatic Go.

# Understanding Hexagonal Architecture

The architecture emphasizes the separation of concerns in software design. The fundamental idea is treat the business logic as the core of everything in the system, separate it from external concerns, such as databases, user interfaces, and external services.

![hex-arch](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/def995ac-af33-59e6-8cb7-2a87ae514771.png)

### Core Business Logic

The Hexagonal Architecture places the core business logic at the heart of the system, independent of any external technologies, libraries or frameworks.

![hexagon](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/4fefd99f-7840-540d-9eca-763ceaa1ffc8.png)

This layer manage the application independent business rules. They encapsulate the most general and high-level logic. It's maybe the entities and value object that contain behaviors. External system or framework change does not affected to the core layer.

### Ports and Adapters:

Ports are just the interfaces, which represent the interactions between the core logic and external systems.

Implement adapters using concrete types that connect the core logic to databases, HTTP servers, or any external dependencies. The left of the hexagon is called **driver adapters** other side is called **driven adapters**.

Also, the driver adapters (adapters from the left of the hexagon) have the responsibility for managing another very crucial type of logic which is *application-specific* business rule (Uncle Bob mentioned many times in his [clean architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html#use-cases) blog & presentations).

### Advantages

**Testability:**

Go's testing capabilities combined with Hexagonal Architecture make it easy to write unit tests for the core business logic, ensuring the application's reliability.

**Flexibility and Adaptability:**

Go's simplicity and flexibility make it easy to swap out adapters, allowing the application to adapt to changes in external systems or technologies.

**Clean and Readable Code:**

The straightforward syntax and idioms of Go contribute to clean and readable code, enhancing the maintainability of the application.
Full code at github [repo](https://github.com/ngoctrng/go-hexagon)

# The Sample Application

Let's get your hand dirty with the sample application. I've written an example using the hexagonal architecture and also include test suite as well

The example contain 2 APIs:

- POST /api/books - Create a book
- GET /api/books/:isbn - Get a book info by isbn

### Component Level Architecture

![hexagonal-sample](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/801dfee5-8601-53fd-af14-9bebd1e22808.png)

It's very simple: 

- We have an adapter (Handler) to deals with HTTP request and response, provide REST api endpoints.
- Handler depend on the core domain (Book) and define an interface to working with the storage. 
- We also have 2 adapters as the implementation for the `Storage` interface show you the flexibility and interchangeability of the architecture, of course secure by tests (all the tests is not included in the blog content, so please check github [repo](https://github.com/ngoctrng/go-hexagon)).

Many implementations of Hexagonal Architecture are frequently used service layer (someone calls them usecases or interactors). I decided not to include a service layer in my implementation. First, because *simplicity matters*, a service layer would have been causing an unnecessary distraction. Second, people usually overuse the service layer to make a big service class that domain-logic and application-logic live in the same place. This eventually turn domain model to an [Anemic Domain Model](https://en.wikipedia.org/wiki/Anemic_domain_model), often described as an anti-pattern in OOP.

But my idea is not limited to 2 layers, feel free to add a service layer to your application when needed. But remember, strive for simplicity in Go application.

### The core

Let's start with the core hexagon. I defined an entity called `Book` and the `Storage` interface in the book domain.

```go
// domain/book/book.go

type Storage interface {
	Save(book *Book) error
	FindByISBN(isbn string) (*Book, error)
}

type Book struct {
	ISBN string
	Name string
}

func NewBook(isbn string, name string) Book {
	return Book{ISBN: isbn, Name: name}
}
```

### HTTP Server Adapter

Here the server adapter provides the REST API endpoints. I use the `book.Storage` interface to decouple code of the http server from the storage implementation gives us the ability to write unit tests without the real storage engine needed.

```go
// adapters/httpserver/server.go

type Server struct {
	Router *echo.Echo
	// storage adapters
	BookStore book.Storage
}

func New() (*Server, error) {
	s := Server{Router: echo.New()}

	s.Router.POST("/api/books", s.CreateBook)
	s.Router.GET("/api/books/:isbn", s.GetBook)

	return &s, nil
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	s.Router.ServeHTTP(w, r)
}

func (s *Server) handleError(c echo.Context, err error, status int) error {
	log.Println(err)
	return c.JSON(status, map[string]string{
		"message": http.StatusText(status),
	})
}
```

Sample tests with testify mock

```go 
t.Run("return status 201 after created bookTest", func(t *testing.T) {
    mockStore.On("Save", &bookTest).Return(nil).Times(1)

    response := httptest.NewRecorder()
    ctx := echo.New().NewContext(newCreateBookRequest(bookTest), response)

    err := server.CreateBook(ctx)

    assert.NoError(t, err)
    assert.Equal(t, http.StatusCreated, response.Code)
    mockStore.AssertExpectations(t)
})
```

### Storage Adapters

I have 2 implementation of Storage interface:

- An in memory storage using the BadgerDB (https://github.com/dgraph-io/badger)

```go
// adapters/inmemstore/book_store.go

type BookStore struct {
	db *badger.DB
}

func NewBookStore(db *badger.DB) *BookStore {
	return &BookStore{db}
}

func (b *BookStore) Save(data *book.Book) error {
	key := []byte(data.ISBN)
	value := []byte(data.Name)
	return b.db.Update(func(txn *badger.Txn) error {
		return txn.Set(key, value)
	})
}

func (b *BookStore) FindByISBN(isbn string) (*book.Book, error) {
	result := book.Book{}
	err := b.db.View(func(txn *badger.Txn) error {
		item, err := txn.Get([]byte(isbn))
		if err != nil {
			return err
		}

		_ = item.Value(func(val []byte) error {
			result.ISBN = string(item.Key())
			result.Name = string(val)
			return nil
		})

		return nil
	})
	if err != nil {
		return nil, err
	}

	return &result, nil
}
```

- The postgresql implementation 

```go 
// adapters/postgrestore/book_store.go

type BookStore struct {
	db *sqlx.DB
}

func NewBookStore(db *sqlx.DB) *BookStore {
	return &BookStore{db}
}

func (s *BookStore) Save(b *book.Book) error {
	_, err := s.db.Exec(`INSERT INTO books(isbn,name) VALUES ($1,$2)`, b.ISBN, b.Name)
	if err != nil {
		return fmt.Errorf("cannot save the book: %w", err)
	}
	return nil
}

func (s *BookStore) FindByISBN(isbn string) (*book.Book, error) {
	var result BookQuerySchema
	err := s.db.Get(&result, `SELECT isbn,name FROM books WHERE isbn=$1`, isbn)
	if err != nil {
		return nil, fmt.Errorf("cannot get the book '%s': %w", isbn, err)
	}

	b := book.NewBook(result.ISBN, result.Name)
	return &b, nil
}
```

### The application

Of course, we have the main application, the dirtiest component in our system. Let's compose all the components and run it. 

And you can switching between the implementations of the Storage and play with it :).

```go 
// cmd/httpserver/main.go

func main() {
	cfg, err := config.LoadConfig()
	if err != nil {
		log.Fatal(err)
	}

	db, err := postgrestore.NewConnection(postgrestore.ParseFromConfig(cfg))
	if err != nil {
		log.Fatal(err)
	}

	server, err := httpserver.New()
	if err != nil {
		log.Fatal(err)
	}
	server.BookStore = postgrestore.NewBookStore(db)

	//db, err := inmemstore.NewConnection()
	//server.BookStore = inmemstore.NewBookStore(db)

	addr := fmt.Sprintf(":%d", cfg.Port)
	log.Println("server started!")
	log.Fatal(http.ListenAndServe(addr, server))
}
```

Now start the application, you'll see the result

```shell
λ  curl -i -X POST -d '{"isbn":"9781642001396","name":"Go Succinctly"}' -H 'Content-Type: application/json' http://localhost:8088/api/books

HTTP/1.1 201 Created
Date: Tue, 30 Jan 2024 08:06:45 GMT
Content-Length: 0
```

```shell
λ  curl -i -X GET -H 'Content-Type: application/json' http://localhost:8088/api/books/9781642001396 
                                       
HTTP/1.1 200 OK
Content-Type: application/json; charset=UTF-8
Date: Thu, 01 Feb 2024 03:18:22 GMT
Content-Length: 48

{"ISBN":"9781642001396","Name":"Go Succinctly"}
```

Please check the github [repo](https://github.com/ngoctrng/go-hexagon) and following the README.

# Conclusion

Hexagonal Architecture offers a holistic approach to software design, prioritizing flexibility, maintainability, and testability. 
Keeping the core business logic at the center and surrounding it with ports and adapters, developers can create robust, scalable, and easily maintainable software systems using Go. As technology continues to change, we will have the confident to update part of the system when it obsoleted with the minimum effor

Hexagonal Architecture, also known as Ports and Adapters pattern, stands out as a powerful pattern that promotes clean, maintainable, and testable code.

Software Design with Hexagonal Architecture in Go

Ngoc Truong

## What is SOLID?

**SOLID** is an acronym representing five crucial principles of object-oriented design programming. It was introduced by [Robert C. Martin](https://en.wikipedia.org/wiki/Robert_C._Martin), with the aim of guiding the construction of flexible, understandable, and maintainable source code.

**S** – Single Responsibility Principle  
**O** – Open Closed Principle  
**L** – Liskov Substitution Principle  
**I**– Interface Segregation Principle  
**D** – Dependency Inversion Principle

The **SOLID** principles are not an absolute solution for all problems, but they provide guidance and fundamental principles for building source code that is easy to maintain and extend.

## Problems SOLID solves in Software Development

1. **Functional Entanglement**
Functional Entanglement refers to a situation during software development in which the responsibilities and functions of different components or modules are not clearly separated. It occurs when the logic of multiple concerns or features become intertwined, making it difficult to understand, maintain, and modify the codebase. This lack of separation can lead to various problems during software development.

2. **Rigidity**
Rigidity in software development refers to a situation where the codebase is inflexible and difficult to modify. This lack of adaptability can arise from design choices, architectural decisions, or coding practices that make it challenging to implement changes or add new features. Rigidity is one of the key issues addressed by software engineering principles and methodologies to enhance the maintainability and scalability of a software system.

3. **Low Reusability**
Low Reusability in software development refers to a situation in which code components, modules, or functions are not designed or structured in a way that promotes easy reuse across other parts. of software systems or in other projects. When code lacks reusability, developers face challenges in leveraging existing solutions for similar or related tasks, leading to increased development effort, duplicate code, and reduced overall efficiency.

4. **Difficulty in Extensibility**
Difficulty in Extensibility in software development refers to challenges faced when attempting to add new features, functionalities, or modifications to a software system. When a system lacks proper design and architectural principles that support easy extensibility, developers may find it cumbersome to adapt the system to changing requirements or incorporate new capabilities.

### S - Single Responsibility Principle
**Original definition**: 

> There should never be more than one reason for a class to change.

If you design a class with multiple responsibilities or 'reasons to change,' you will be required to modify the same code whenever any of those responsibilities needs to change. This not only elevates the risk of unintentionally disrupting one feature while making changes but also goes against the principle of having a single reason to modify a class.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/254c67c5-d163-510c-976b-23559e52909b.png)

Imagine when you need to replace or repair a saw blade, you need to disassemble the parts to do so and then reassemble them. This hides the risk that other components may not operate smoothly or worse, cannot be used anymore, which will not happen if the SRP is followed.

**New definition**: 

> Each module should do one thing and do it well.

This principle is closely related to the topic of high cohesion. Essentially, your code should not mix multiple roles or purposes together.

### O - Open/Closed Principle
**Original definition**: 

> Software entities should be open for extension, but closed for modification.

In some design paradigms, you can create classes and extend them (by creating a subclass), but modifying the original class is restricted. The idea of keeping things "open for extension" is to minimize reliance on the class author. Constantly seeking modifications from the original author or delving into the class to make changes can be impractical. Additionally, open modification tends to introduce multiple concerns into a class, violating the single responsibility principle.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/02360ff3-1a89-50e1-86d8-547b6d864f4e.png)
**New definition**: 

> You should be able to use and add to a module without rewriting it.

The Open/Closed Principle is evident in Visual Studio Code's extension system. VS Code is open for extension, providing a well-defined API for developers to add new features without modifying the core codebase. This allows for a diverse ecosystem of extensions, each contributing to VS Code's functionality without altering its original source code, showcasing the principle of being closed for modification.

### L - Liskov Substitution Principle
**Original definition**: 

> If S is asubtype of T, then objects of type T may be replaced with objects of type S without altering any of the desirable properties of the program.

This principle refers to objects of a superclass should be interchangeable with objects of its subclasses without impacting the program's correctness. In frontend development, LSP extends to derived components replacing base components seamlessly, maintaining expected behavior. Derived components should support the same props, methods, and behavior as the base component, with added context-specific features. Adhering to LSP fosters interchangeable components, enhancing reusability, modularity, and maintainability.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/2c171c1a-5eed-52f5-9901-c01e5855eaa3.png)
**New definition**: 

> You should be able to substitute one thing for another if those things are declared to behave the same way.

This principle advocates for consistent contracts among components, simplifying reasoning and collaboration across diverse components in the application.

### I - Interface Segregation Principle
**Original Definition**: 

> Many client-specific interfaces are better than one general-purpose interface.

This principle refers to the importance of keeping interfaces slim and relevant to the clients that implement them. It's one of the SOLID principles, a set of design principles in object-oriented software development aimed at making software designs more understandable, flexible, and maintainable.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/065dff28-2497-5bcb-a255-9fcb1c5ad598.png)
**New Definition**: 

> Don't show your clients more than they need to see.

Consolidating interfaces can introduce complexity to individual objects, resulting in ambiguity regarding functions and tasks not explicitly associated with the object's construction. This goes against the principles of SOLID, particularly the Single Responsibility Principle, as it may lead to unclear and entangled responsibilities within the codebase. Objects should not be forced to depend upon interfaces that they don't use.

### D - Dependency Inversion Principle
**Original definition**: 

> Depend upon abstractions, not concretions.

This principle refers to the following two principles:
- High-level modules should not depend on low-level modules. Both should depend on abstraction.
- Interface (abstraction) should not depend on details, but the opposite. (Classes communicate with each other through interfaces, not through implementations.)

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/e678cc67-6f75-52c2-a957-241b0d270f52.png)
**New definition**: 

> Depend upon abstractions, not concretions.

To make it easier to understand, look at the electric lights in your house. Here, the high-level module is the electrical outlet, the main interface is the tail light, and the two low-level modules are the light bulb and the fluorescent light bulb.

These two modules both inherit the circular bulb interface. We can easily change the two types of bulbs because the high-level module (electrical socket) only cares about the interface (round bulb), not the implementation (circular or fluorescent bulbs).


## Conclusion
To restate "modern SOLID" one more time:
- Don't surprise the people who read your code.
- Don't surprise the people who use your code.
- Don't overwhelm the people who read your code.
- Use sane boundaries for your code.
- Use the right level of coupling—keep things together that belong together, and keep them apart if they belong apart.

Good code is good code—that's not going to change, and SOLID is a, well, solid basis to practice that!

## Reference document

To learn more about SOLID principles and their introduction by Robert C. Martin, you can refer to his works such as "[Design Principles and Design Patterns](https://staff.cs.utu.fi/~jounsmed/doos_06/material/DesignPrinciplesAndPatterns.pdf)" or "[Clean Code: A Handbook of Agile Software Craftsmanship](https://cuongquach.com/ebook-clean-code-pdf-download-free.html)".

Understanding SOLID is the key to effective source code development, while recognizing the limitations and obstacles in the process of applying SOLID.

"Welcome to a realm
where tech stories unfold."

Discovering Tech Wonders: Dive into Our Top Four Blogs Today!

Introducing EazyMock's Latest Features: Elevate Your Mocking Experience

Mastering EazyMock: Create your first mock API - Part 1

Tanstack, Đấng Cứu Thế Mới (Phần 1)

Mastering EazyMock: Advanced Rules Feature Guide - Part 2

Must-read

Introducing EazyMock's Latest Features: Elevate Your Mocking Experience

Mastering EazyMock: Create your first mock API - Part 1

Mastering EazyMock: Advanced Rules Feature Guide - Part 2

API Mocking: The Complete Guide

Recent blogs

Functional Programming: Where Bugs Become Elegant Puzzles (Part 3)

Functional Programming: Where Bugs Become Elegant Puzzles (Part 2)

Functional Programming: Where Bugs Become Elegant Puzzles

Tanstack, Đấng Cứu Thế Mới (Phần 1)

Software Design with Hexagonal Architecture in Go

SOLID principles: Efficient Software Development Guide

Popular Tags

Let's EazyMock together

"Welcome to a realm where tech stories unfold."

Discovering Tech Wonders: Dive into Our Top Four Blogs Today!

Introducing EazyMock's Latest Features: Elevate Your Mocking Experience

Mastering EazyMock: Create your first mock API - Part 1

Tanstack, Đấng Cứu Thế Mới (Phần 1)

Mastering EazyMock: Advanced Rules Feature Guide - Part 2

Must-read

Introducing EazyMock's Latest Features: Elevate Your Mocking Experience

Mastering EazyMock: Create your first mock API - Part 1

Mastering EazyMock: Advanced Rules Feature Guide - Part 2

API Mocking: The Complete Guide

Recent blogs

Functional Programming: Where Bugs Become Elegant Puzzles (Part 3)

Functional Programming: Where Bugs Become Elegant Puzzles (Part 2)

Functional Programming: Where Bugs Become Elegant Puzzles

Tanstack, Đấng Cứu Thế Mới (Phần 1)

Software Design with Hexagonal Architecture in Go

SOLID principles: Efficient Software Development Guide

Popular Tags

Let's EazyMock together

"Welcome to a realm
where tech stories unfold."