## 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

## 1. Testing of function ( Functional testing)
Kiểm thử chức năng là kiểm tra xem hệ thống có hoạt động theo đúng theo các yêu cầu nghiệp vụ không? Kiểm thử chức năng được thực hiện ở tất cả các mức kiểm thử.

1. Kiểm thử chức năng có thể thực hiện theo 2 quan điểm: requirements-based và business process - based

- **Requirements - based:** Sử dụng các đặc tả yêu cầu của hệ thống làm cơ sở để design test. Một cách tốt để bắt đầu là sử dụng bảng nội dung của đặc tả yêu cầu như một danh sách các mục kiểm thử và không kiểm thử. Chúng ta nên xét độ ưu tiên của yêu cầu dựa trên các tiêu chí rủi ro và sử dụng độ ưu tiên để kiểm thử. Điều này sẽ đảm bảo những phần quan trọng nhất sẽ được kiểm thử.

- **Business - process - based:** sử dụng các kiến thức về quy trình nghiệp vụ. Quy trình nghiệp vụ mô tả các kịch bản liên quan đến nghiệp vụ hằng ngày của hệ thống.

2. Kiểm thử chức năng bao gồm 5 bước:

- Xác định các chức năng mà phần mềm mong muốn sẽ thực hiện.
- Tạo các dữ liệu đầu vào dựa trên các tài liệu đặc tả kỹ thuật của các chức năng.
- Xác định các kết quả đầu ra dựa trên các tài liệu đặc tả kỹ thuật của các chức năng.
- Thực hiện các trường hợp kiêm thử.
- So sánh kết quả thực tế và kết quả mong muốn.

3. Các loại kiểm thử chức năng bao gồm:

- Kiểm thử đơn vị (Unit Testing)
- Smoke Testing
- Sanity Testing
- Kiểm thử giao diện (Interface Testing)
- Kiểm thử tích hợp (Integration Testing)
- Kiểm thử hệ thống (System Testing)
- Kiểm thử hồi quy (Regression Testing)
- Kiểm thử chấp nhận (Acceptance Testing)

## 2. Testing of software product characteristics (Non - Functional testing)
Kiểm thử phi chức năng là các đặc tính chất lượng của hệt thống sẽ được kiểm tra. Chúng ta quan tâm đến việc mọi thứ hoạt động tốt không? Hay nhanh như thế nào? Chúng ta sẽ kiểm tra những thứ cần phải đo như thời gian phản hồi, hay bao nhiêu người có thể đăng nhập cùng một lúc? Kiểm thử phi chức năng cũng giống như kiểm thử chức năng được thực hiện ở tất cả các cấp độ kiểm thử.

1. Kiểm thử phi chức năng bao gồm:

- Kiểm thử hiệu năng (Performance testing)
- Kiểm thử khả năng chịu tải (Load testing)
- Kiểm thử áp lực (Stress testing)
- Kiểm thử tính khả dụng (Usability testing)
- Kiểm thử bảo trì (Maintainability testing)
- Kiểm thử độ tin cậy (Reliability testing)
- Kiểm thử tính tương thích (Portability testing)

2. Các đặc điểm và các đặc điểm phụ tương ứng:

- **Chức năng** (Functionality) gồm 5 đặc điểm phụ: sự phù hợp, chính xác, bảo mật, khả năng tương tác và tuân thủ.
- **Độ tin cậy** (Reliability) gồm 4 đặc điểm phụ: độ bền, khả năng chịu lỗi, khả năng phục hồi và tuân thủ.
- **Khả năng sử dụng** (Usability) gồm 5 đặc điểm phụ: dễ hiểu, khả năng học hỏi, khả năng hoạt động, sự thu hút và tính tuân thủ.
- **Tính hiệu quả** (Efficiency) gồm 3 đặc điểm phụ: thời gia (hiệu suất), sử dụng tài nguyên và tuân thủ.
- **Khả năng bảo trì** (Maintainability) gồm 5 đặc điểm phụ: khả năng phân tích, khả năng thay đổi, tính ổn định, khả năng kiểm tra và tuân thủ.
- **Tính tương thích** (Portability) gồm 5 đặc điểm phụ: khả năng thích ứng, khả năng cài đặt, cùng tồn tại, khả thăng thay thế và tuân thủ.

## 3.Testing of software structure/architecture ( Structural testing)

- Kiểm thử cấu trúc thường được gọi là "hộp trắng" hoặc "hộp thủy tinh" vì chúng quan tâm đến những gì đang xảy ra bên trong hộp.
- Kiểm thử cấu trúc thường được sử dụng như một cách đo lường của kiểm thử thông qua độ bao phủ của một tập hợp các yếu tố cấu trúc hoặc các mục bao phủ.
- Nó có thể xảy ra ở bất kỳ mức độ kiểm thử nào chủ yếu ở kiểm thử thành phần, tích hợp.
- Ở cấp độ thành phần, và mức thấp hơn trong kiểm thử tích hợp thành phần có hỗ trợ công cụ tốt để đo mức độ bao phủ của mã. Các công cụ đo lường độ bao phủ đánh giá tỉ lệ phần trăm thực thi đã được thực hiện bởi một bộ kiểm thử. Nếu độ bao phủ không phải là 100% thì các kiểm thử bổ sung có thể cần phải được viết và chạy để bao phủ những phần chưa được thực hiện.
- Các kỹ thuật được sử dụng để kiểm tra cấu trúc là kỹ thuật kiểm thử hộp trắng, các mô hình luồng điều khiển thường sử dụng để hỗ trợ kiểm thử cấu trúc.

## 4.Testing related to changes (Confirmation and regression testing)

1. Confirmation testing (Kiểm thử xác nhận)

- Khi kiểm thử bị lỗi, và chúng ta xác định nguyên nhân lỗi là do lỗi phần mềm, lỗi được báo cáo, khi một phiên bản mới của phần mềm đã sửa lỗi. Trong trường hợp này chúng ta cần thực hiện kiểm tra một lần nữa để xác định rằng lỗi thực sự đã được sửa.
- Khi thực hiện kiểm tra xác nhận điều quan trọng là phải đảm bảo rằng thử nghiệm được thực hiện chính xác giống như lần đầu tiên, sử dụng cùng một đầu vào, dữ liệu và môi trường. Nếu bây giờ đúng có nghĩa là phần mềm chính xác. Chúng ta biết rằng ít nhất một phần của phần mềm là chính xác, nhưng điều đó là không đủ. Sửa lỗi có thể gây ra một lỗi khác trong phần mềm. Cách phát hiện các bất lợi ngoài ý muốn của việc sửa lỗi là thực hiện kiểm thử hồi quy.

2. Regression testing (Kiểm thử hồi quy)

- Giống như kiểm thử xác nhận kiểm thử hồi quy liên quan đến việc thực hiện các trường hợp kiểm thử đã được thực hiện trước đó. Sự khác biệt là đối với kiểm thử hồi quy, các trường hợp kiểm thử có thể đúng ở lần cuối cùng chúng được thực thi.
- Mục đích của kiểm thử hồi quy để xác minh rằng các sửa đổi trong phần mềm hoặc môi trường không gây ra bất lợi ngoài ý muốn và hệ thống vẫn đáp ứng các yêu cầu của nó.
- Bộ kiểm thử hồi quy hoặc gói kiểm tra hồi quy là một tập hợp các trường hợp kiểm thử được sử dụng đặc biệt để kiểm tra hồi quy. Chúng được thiết kế để thực hiện hầu hết các chức năng trong một hệ thống nhưng không chi tiết bất kỳ chức năng nào. Tất cả các trường hợp trong bộ kiểm thử hồi quy sẽ được thực thi mỗi khi một phiên bản mới của phần mềm được phát hành và điều này làm cho chúng trở lên lý tưởng cho tự động hóa.
- Kiểm thử hồi quy được thực hiện khi phần mềm thay đổi, do sửa lỗi, chức năng mới. Nó cũng là một ý tưởng tốt để thực thi chúng khi một vài khía cạnh của môi trường thay đổi.

Tài liệu tham khảo https://www.utcluj.ro/media/page_document/78/Foundations%20of%20software%20testing%20-%20ISTQB%20Certification.pdf
https://www.softwaretestingclass.com/functional-testing-vs-non-functional-testing/

Test Type có thể được hiểu là sự phân loại các hoạt động kiểm thử theo mục đích, chiến thuật kiểm thử. Mỗi Test Type sẽ gắn với một mục tiêu kiểm thử nhất định.

Test Type

Quân Lê

CSS animations have revolutionized web design, allowing developers to create dynamic, engaging experiences with ease. Whether you’re aiming for subtle transitions or vibrant effects, CSS offers a variety of animation techniques. In this blog post, we’ll explore different types of CSS animations, delve into their specifics, and provide basic examples to get you started.

## Why Use CSS Animations?
Before diving into the types and examples, let's briefly discuss why CSS animations are so valuable:
1. **Enhanced User Experience:** Animations can make interfaces more intuitive by providing visual feedback and guiding user interactions.
2. **Visual Appeal:** Well-designed animations can make your website more attractive and engaging.
3. **Performance:** CSS animations are generally more performant than JavaScript animations, as they can be optimized by the browser.

## Types of CSS Animations
1. Transitions
2. Keyframe Animations
3. Transforms

## 1. Transitions
Transitions are a simple way to animate changes in CSS properties. They enable smooth, gradual changes when an element’s state changes, such as when it’s hovered over or clicked. Transitions are easy to implement and are ideal for basic animations.

**Basic Transition Example**
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/LPTC1QboAVSjUkaQGxJD0.webp)
**Notes:** In this example, when you hover over the box, its background color smoothly transitions from coral to light blue over 0.5 seconds. Transitions are great for hover effects, focus effects, and other state changes that need to be smooth.

## 2. Keyframe Animations
Keyframe animations provide more control than transitions by allowing you to define multiple steps of an animation sequence. You can create complex animations by specifying styles at various points along the animation timeline.

**Basic Keyframe Animation Example**
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/7xNnV-x7DsdV6HgGs7oyz.webp)
**Notes:** Here, the box moves 200px to the right and rotates 360 degrees over 4 seconds, then repeats infinitely. Keyframe animations are ideal for more intricate animations like spinners, loaders, and other multi-step sequences.

## 3. Transforms
Transforms allow you to manipulate the size, position, and shape of an element. While not animations per se, they are often used in conjunction with transitions and keyframe animations to create engaging effects.

**Basic Transform with Transition Example**
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/8XeJMfHp3epnPUZlb1Yfy.webp)
**Notes:** In this example, hovering over the box scales it up by 1.5 times its original size and rotates it 45 degrees, with a smooth transition. Transforms are powerful when combined with transitions, allowing for effects like scaling, rotating, and skewing elements smoothly.

## Combining Animations
You can combine transitions, keyframe animations, and transforms to create more complex animations. Here’s an example:

**Combined Example**
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/4Z_8xfxiuFBcDLGFGyGjC.webp)
**Notes:** In this combined example, the box bounces up and down while also rotating, creating a dynamic and engaging effect. Combining different animation techniques can lead to sophisticated and visually impressive effects.

## Advanced CSS Animation Techniques
**CSS Variables**
CSS variables (custom properties) can be used to create dynamic animations. They allow you to define values in one place and reuse them throughout your CSS.
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/iOPcfEhUOHr1m13HzWOdc.webp)
**Notes:** Using CSS variables allows for easier maintenance and consistency across your animations. You can quickly adjust the variables to see changes across all instances where they are used.

**Animation Performance Tips**
- **Use Transform and Opacity:** Animating `transform` and `opacity` properties is typically more performant because these animations can be handled by the GPU.
- **Limit Repaints and Reflows:** Avoid animating properties that trigger layout changes (like `width` and `height`), as these can cause repaints and reflows, leading to jank.
- **Hardware Acceleration:** Use `will-change` to hint the browser about upcoming changes.
![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/7qsNm-H9cCNAdIOtg4hYo.webp)
**Notes:** Optimizing performance is crucial for ensuring smooth animations, especially on lower-end devices. By following these tips, you can create animations that not only look good but also perform well.

## Let do it
CSS animations are a powerful tool for enhancing web designs, making them more interactive and visually appealing. By mastering transitions, keyframe animations, and transforms, you can create a wide range of effects to captivate your audience. Understanding how to optimize animations for performance is equally important to ensure a smooth user experience.

Start experimenting with these techniques and see how CSS animations can bring your web projects to life!

Animation CSS: Websites are more than just rigid dummies

Lê Tâm

[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

# TanStack is The messiah - Part 1

## 1) What is TanStack?

TanStack is an open-source software development toolkit that provides a range of solutions enabling developers to build web and mobile applications efficiently, quickly, and robustly. TanStack includes various tools and libraries, all designed to optimize the development process, from application state management and data handling to UI creation.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/L8ZsBSp5wqT2yhmH-zF8c.webp)

TanStack is currently being developed and widely used with popular libraries such as:

- [TanStack Query:](https://tanstack.com/query/latest) Powerful asynchronous state management for TS/JS, React, Solid, Vue, Svelte and Angular
- [TanStack Table](https://tanstack.com/table/latest): Headless UI for building powerful tables & datagrids - Supercharge your tables or build a data grid from scratch for TS/JS, React, Vue, Solid & Svelte while retaining 100% control over markup and styles.
- [TanStack Router](https://tanstack.com/router/latest): Modern and scalable routing for React applications - A fully type-safe React router with built-in data fetching, stale-while revalidate caching and first-class search-param APIs.
- [TanStack Virtual](https://tanstack.com/virtual/latest): Headless UI for Virtualizing Large Element Lists - Virtualize only the visible DOM nodes within massive scrollable elements at 60FPS in TS/JS, React, Vue, Solid & Svelte while retaining 100% control over markup and styles.

## 2) Why is TanStack called the messiah

Let's compare TanStack with other libraries.

### 2.1 TanStack Query vs RTK Query

*If you have ever worked with both of these libraries, your initial impression will definitely be:* 

> Why is TanStack Query so easy to use and set up?
> 

> When using TanStack Query, the number of lines of code (LOC) significantly decreases.
> 

**Fact**: RTK Query is designed to complement Redux Toolkit as a tool that not only supports data-fetching but also manages state. However, this also imposes limitations on RTK Query - it cannot be used standalone, leading to significant constraints on **bundle size as well as complexity in setup and usage**

On the other hand, TanStack Query is a standalone tool that can operate independently without relying on any other library. Setting up and using it is much easier compared to its competitors. Additionally, it offers features such as support for Infinite Query, Devtool, and more…[(To Reference)](https://tanstack.com/query/latest/docs/framework/react/comparison#comparison-or-react-query-vs-swr-vs-apollo-vs-rtk-query-vs-react-router)

**Real-world Problems:** With a project set up by **RTK Query** and **NextJs**

At first, to support data fetching on the server side. Nothing happened until then our project encountered a serious issue on the server - **Memory leak**
The initial cause was identified as stemming from RTK Query's requirement of using an additional third-party library recommended by Redux itself: **next-redux-wrapper**. This library, combined with the inability of RTK Query to clear memory, led to memory accumulation on the server side [to a level where immediate clearing became unattainable for us.](https://github.com/reduxjs/redux-toolkit/issues/3988#issuecomment-1929552259)

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/xfZiMoT3fqm2BJ2epC-ax.webp)

**TanStack** has come as The messiah. We have switched to using [TanStack Query](https://tanstack.com/query/latest) with features almost identical but supported with server-side memory clearing.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/BgidRq-cmEQVVGteBirBG.webp)


### 2.2 TanStack Router vs React Router

[React Router](https://reactrouter.com/en/main) is one of the best third-party libraries for React Developer

[TanStack Router](https://tanstack.com/router/latest) has recently been introduced with version v1, but it has garnered significant attention from the community due to its numerous advantages and promising potential to potentially replace its predecessor.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/HMG7CnE6o1gyv6rIB7M4k.webp)

***What is the advantage of this product?***

Besides the features nearly identical to its predecessor React Router, TanStack Router also boasts notable features such as

- **Type safe 100%** :  allowing users to opt for Typesafe navigation.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/L4qR4-aslWYcEBt-7mAEo.webp)

- **File-base navigate:** Anyone who has used frameworks like Next.js or Remix, this feature won't be too unfamiliar. It's a feature that allows you to automatically create your routes when creating files without the need for manual intervention.
- **Validate Param:** This is a fairly new feature of the TanStack Router. It allows you to validate the parameters received from the URL before bringing them down and using them, thus enhancing security and code quality.

![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)**: The TanStack Router introduces the **beforeLoad** method, allowing you to perform authentication prior to rendering a component. This eliminates the need to create a **higher-order component (HOC)** and wrap the pages requiring authentication as you had to do previously.

![img](https://easymock-blog-prod-qovya.s3.ap-southeast-1.amazonaws.com/yhxUdRzyR1S-_NF3FNwUN.webp)

## Summing Up

TanStack has produced many libraries and is still in the process of development. These libraries are highly regarded by the community and show positive signs. In addition to the aforementioned libraries, TanStack is still developing many other open-source libraries. Let's wait and see if these libraries can change the game among the current giants.

# TanStack is The messiah - Part 1

Kiet Do

EazyMock

MockAPI

Guide

Blogs

NextFeature

Mastering

system-design

architecture

hex-arch

animation

Monads

Functional

Tanstack

React

principles

patterns

Programming

Programing

Recursion

FunctionalTest

SmokeTest

UnitTest

SystemTest

SanityTest

TEQNOLOGICAL

EAZYMOCK

# 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.

"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

Software Design with Hexagonal Architecture in Go

Animation CSS: Websites are more than just rigid dummies

API Mocking: The Complete Guide

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

Test Type

Animation CSS: Websites are more than just rigid dummies

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 is The messiah - Part 1

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

Software Design with Hexagonal Architecture in Go

Animation CSS: Websites are more than just rigid dummies

API Mocking: The Complete Guide

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

Test Type

Animation CSS: Websites are more than just rigid dummies

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 is The messiah - Part 1

Popular Tags

Let's EazyMock together

"Welcome to a realm
where tech stories unfold."