Benchmark: POJOs vs Immutable Maps

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/immutable/4.1.0/immutable.min.js" integrity="sha512-OQDhbg3GkxL1XYlKM3zUzP9fYbL93uBQU6fsSl0tpr5aUp1CV3AI7hMgMVJqlCy63ppR5Ff/pk68ZjPAOjIgiQ==" crossorigin="anonymous" referrerpolicy="no-referrer"></script>

Script Preparation code:

var numElements = 1000000;

var pojosMap = {};
var mapWithPojos = Immutable.Map({});
var mapWithMaps = Immutable.Map({});

for (let i = 0; i < numElements; i++) {
    pojosMap[i] = { foo: i };
    mapWithPojos = mapWithPojos.set(i, { foo: i });
    mapWithMaps = mapWithMaps.set(i, Immutable.Map({ foo: i }));
}

Tests:

Pojo insert
pojosMap = { ...pojosMap, foo: { baz: 'bar' } }
Map with pojos insert
mapWithPojos = mapWithPojos.set('foo', { baz: 'bar' })
Map with maps insert
mapWithMaps = mapWithMaps.set('foo', Immutable.Map({ baz: 'bar' }))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Pojo insert
Map with pojos insert
Map with maps insert

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark definition and explain what is being tested.

**Benchmark Definition**

The benchmark defines two types of data structures: POJOs (Plain Old JavaScript Objects) and Immutable Maps. The goal is to compare the performance of inserting data into these two types of data structures.

**POJOs vs Immutable Maps**

In this benchmark, we have:

1. `pojosMap`: an object that uses traditional JavaScript objects to store data.
2. `mapWithPojos`: an Immutable Map created using the Immutable library.
3. `mapWithMaps`: another Immutable Map created using the Immutable library.

The benchmark tests how quickly each of these data structures can be updated by inserting new data.

**Options Compared**

We have two main options being compared:

* **POJOs**: Using traditional JavaScript objects to store and update data.
* **Immutable Maps**: Using the Immutable library to create and update Immutable Maps.

**Pros and Cons**

**POJOs:**

Pros:

* Simple and familiar API
* No additional dependencies required (just standard JavaScript)

Cons:

* Not thread-safe by default (can lead to concurrency issues)
* Can be slower due to object creation and modification overhead

**Immutable Maps:**

Pros:

* Thread-safe and predictable performance
* Provides a clear and concise API for data manipulation

Cons:

* Requires additional dependencies (the Immutable library)
* Can be more complex to understand and use, especially for beginners

**Library - Immutable Map**

The Immutable Map is a library that provides a thread-safe and predictable way to work with immutable data structures. It's designed to provide a simple and consistent API for data manipulation, making it easier to write concurrent code.

In the benchmark, `mapWithPojos` uses the Immutable Map API to insert new data, while `mapWithMaps` creates a new Immutable Map instance every time an update is needed.

**Special JS Feature or Syntax**

One special feature used in this benchmark is the use of the `Immutable.Map` constructor to create Immutable Maps. This allows for creating and updating Immutable Maps in a thread-safe and predictable way.

Another notable aspect is the use of the `set()` method on the Immutable Map instances, which updates the map with new data in a single operation.

**Other Alternatives**

If you're interested in exploring other alternatives, here are a few options:

* **Lodash**: A popular utility library that provides many functions for working with arrays and objects.
* **Mongoose**: A MongoDB object modeling tool that provides a convenient way to interact with MongoDB data structures.
* **TypeScript**: A statically typed language that can provide better type safety and performance benefits than JavaScript.

However, it's worth noting that these alternatives may not be as well-suited for this specific benchmark, which focuses on comparing POJOs vs Immutable Maps.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36

Browser/OS: Chrome 104 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Pojo insert	6.8 Ops/sec
Map with pojos insert	2203119.2 Ops/sec
Map with maps insert	1353708.1 Ops/sec

Related benchmarks:

POJOs vs Immutable Maps (version: 1)

Comparing performance of: Pojo insert vs Map with pojos insert vs Map with maps insert

Created: 2 years ago by: Registered User

Jump to the latest result

Pojo insert

Map with pojos insert

Map with maps insert

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 24 days ago):