Benchmark: obfuscator.io low preset vs no obfuscation 2

Tests:

Obfuscated (low preset) code
function _0x1828(){var _0x144333=['848924aTuPJM','1773912NDpROP','3070746kYXrFw','5885585fdTsAm','1741986GzpRap','1132536nqhXol','3857920pVvnkR'];_0x1828=function(){return _0x144333;};return _0x1828();}(function(_0x529674,_0x585086){var _0x56e0a8=_0xc20e,_0x50e5ac=_0x529674();while(!![]){try{var _0x1a1f25=parseInt(_0x56e0a8(0x19d))/0x1+parseInt(_0x56e0a8(0x19b))/0x2+parseInt(_0x56e0a8(0x19a))/0x3+-parseInt(_0x56e0a8(0x19c))/0x4+-parseInt(_0x56e0a8(0x199))/0x5+parseInt(_0x56e0a8(0x198))/0x6+parseInt(_0x56e0a8(0x19e))/0x7;if(_0x1a1f25===_0x585086)break;else _0x50e5ac['push'](_0x50e5ac['shift']());}catch(_0x851b58){_0x50e5ac['push'](_0x50e5ac['shift']());}}}(_0x1828,0x973c8));function hi(){console['log']('Hello\x20World!');}function _0xc20e(_0x41ed62,_0x523817){var _0x182836=_0x1828();return _0xc20e=function(_0xc20e05,_0x4565ac){_0xc20e05=_0xc20e05-0x198;var _0x9c4737=_0x182836[_0xc20e05];return _0x9c4737;},_0xc20e(_0x41ed62,_0x523817);}hi();
Non-obfuscated code
// Paste your JavaScript code here function hi() { console.log("Hello World!"); } hi();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Obfuscated (low preset) code
Non-obfuscated code

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and its test cases.

**Benchmark Overview**

The `MeasureThat.net` website allows users to create and run JavaScript microbenchmarks. The provided benchmark compares the performance of two types of code: obfuscated (low preset) and non-obfuscated code.

**Options Compared**

In this benchmark, we have two options:

1. **Obfuscated Code**: The first test case has a small piece of JavaScript code that uses a custom implementation of the `parseInt` function to concatenate strings with numbers. This is an example of code obfuscation, where the code is intentionally made difficult to understand or read.
2. **Non-Obfuscated Code**: The second test case has a simple "Hello World!" message printed to the console using the built-in `console.log()` function.

**Pros and Cons**

* **Obfuscated Code**:
	+ Pros: Can be used to hide malicious code, make it harder for attackers to understand the intent of the code.
	+ Cons: May result in slower execution times due to the custom implementation, which can lead to performance issues.
* **Non-Obfuscated Code**:
	+ Pros: Faster execution times since it uses built-in functions and libraries that are optimized for performance.
	+ Cons: More readable and maintainable code, but potentially vulnerable to security threats if not properly sanitized.

**Libraries and Special Features**

In this benchmark, we don't see any explicit library usage or special JavaScript features (like async/await or Promises) being tested. However, it's worth noting that the `parseInt` function is a built-in JavaScript function that can be used in both cases.

**Other Considerations**

When creating benchmarks, consider the following factors:

* **Code readability and maintainability**: Benchmarking code should not prioritize performance over readability.
* **Library usage**: If using libraries or frameworks, make sure they are properly initialized and configured to ensure accurate results.
* **Device and browser variability**: Test on multiple devices and browsers to account for potential hardware and software differences.

**Alternative Benchmarks**

Some alternative benchmark types include:

* **CPU-bound benchmarks**: Measure the performance of CPU-intensive tasks, such as matrix multiplication or cryptanalysis.
* **Memory-bound benchmarks**: Evaluate the performance of memory-intensive tasks, like data compression or encryption.
* **Network-based benchmarks**: Test the performance of network operations, like HTTP requests or WebSocket connections.

Keep in mind that these alternatives may require more complex setup and configuration than a simple JavaScript microbenchmark.

Latest run results:

Run details: (Test run date: 10 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Obfuscated (low preset) code	18771.1 Ops/sec
Non-obfuscated code	59902.6 Ops/sec

Related benchmarks:

obfuscator.io low preset vs no obfuscation 2 (version: 0)

obfuscation vs no obfuscation performance

Comparing performance of: Obfuscated (low preset) code vs Non-obfuscated code

Created: one year ago by: Guest

Jump to the latest result

Obfuscated (low preset) code

Non-obfuscated code

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):