Tagged articles
IEEE 754
16 articles · Page 1 of 1
This article explains how Snowflake IDs exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision when parsed as JSON numbers, causing silent bugs like 'record not found', and recommends returning IDs as strings via Jackson's ToStringSerializer or a custom @JsonId annotation, while keeping numeric fields as numbers, aligning API contracts, OpenAPI specs, and frontend types.
API DesignIEEE 754JSON Serialization
0 likes · 21 min read

This article explains how JavaScript's reduce method loses precision when summing large or many numbers due to floating-point rounding, introduces the new ES2026 Math.sumPrecise() method that avoids intermediate rounding errors, demonstrates its accuracy with examples like summing 1e20, 0.1, -1e20 and 1000 times 0.1, and notes current browser support.
ES2026IEEE 754JavaScript
0 likes · 6 min read

This article explains why PHP's IEEE 754 floating-point arithmetic causes 0.1 + 0.2 ≠ 0.3, demonstrates integer overflow issues near PHP_INT_MAX, and details correct approaches: tolerance-based comparison, integer fixed-decimal scaling, and arbitrary-precision extensions BCMath and GMP with string inputs.
BCMathGMPIEEE 754
0 likes · 12 min read

Floating‑point calculations can yield different results on Windows, macOS and Linux due to JVM optimisations; the strictfp keyword forces Java to follow the IEEE‑754 standard exactly, disabling hardware‑level precision tricks so that the same code produces identical results on any OS, CPU or JVM implementation.
IEEE 754JavaStrictMath
0 likes · 18 min read


ITPUBApr 19, 2026 · Fundamentals
This article demystifies why adding two approximated 0.1 values yields an exact 0.2 in floating‑point arithmetic while adding 0.1 and 0.2 fails to produce an exact 0.3, by detailing IEEE‑754 double‑precision storage, binary conversion, rounding effects, and Java code verification.
IEEE 754InterviewJava
0 likes · 9 min read

This article explores the surprising result that adding every IEEE‑754 floating‑point number between –1 and 1, even with exhaustive brute‑force enumeration in Rust, yields a non‑zero sum due to representation limits, rounding errors, and accumulation order effects.
IEEE 754Kahan-summationRust
0 likes · 7 min read
![Why Summing All Floats in [-1, 1] Doesn’t Produce Zero – A Brute‑Force Study](https://wsrv.nl/?url=https%3A%2F%2Fmmbiz.qpic.cn%2Fsz_mmbiz_jpg%2Fh1dibp9WKYiaObWtYVHfytWwhOaM4FIYVbNUcRsZlwJuic4ACYpkKjww4uU9u24I4TsRgDZsC1GEjfBZ6sXTSfwIrbNqbDXGqOzTCEhBkddianU%2F0%3Fwx_fmt%3Djpeg)
This article explains scientific notation, the IEEE‑754 floating‑point standard, the structure of FP32 and FP64 numbers, and how computational power is measured using FLOPS, illustrating CPU and GPU FP32 performance calculations and why FP32 is the common benchmark for AI workloads.
CPUFP32GPU
0 likes · 17 min read

Python’s unexpected 0.1 + 0.2 = 0.30000000000000004 result stems from binary floating‑point representation limits defined by the IEEE 754 standard, and the article explains this issue, rounding modes, and practical solutions such as the decimal module, fractions, math.isclose, and high‑precision NumPy types.
IEEE 754NumPyPython
0 likes · 9 min read

The article explains why comparing floating‑point numbers with == in Java often yields unexpected results, describes the IEEE‑754 representation of float and double, demonstrates common pitfalls through code examples, and provides step‑by‑step methods for converting decimal fractions to binary.
IEEE 754Javabinary conversion
0 likes · 10 min read

This article explains why adding the decimal numbers 0.1 and 0.2 in binary floating‑point arithmetic yields the surprising result 0.30000000000000004, by detailing the exact 64‑bit representations, the rounding‑to‑nearest‑even rule, and step‑by‑step Python calculations that expose the underlying IEEE‑754 mechanics.
IEEE 754PythonRounding
0 likes · 10 min read

JavaScript’s built‑in toFixed cannot reliably perform true rounding due to binary floating‑point precision limits, so this article explains the underlying IEEE‑754 representation, demonstrates common pitfalls, and provides a custom rounding algorithm with code examples to achieve accurate decimal rounding.
IEEE 754Roundingfloating-point
0 likes · 10 min read

This curated list highlights the latest breakthroughs in frontend engineering, covering component‑driven responsive design, the JavaScript pipeline operator, React's useEvent hook, WebContainer architecture, IEEE‑754 double‑precision floating‑point details, native debounce in React, low‑code visual systems, object key ordering, Blink rendering, and a comparative review of browser code editors.
IEEE 754WebAssemblycode editors
0 likes · 5 min read

JavaScript’s 0.2 + 0.1 yielding 0.30000000000000004 stems from binary floating‑point representation, where many decimal fractions cannot be expressed exactly; the article explains decimal‑to‑binary conversion, the repeating binary of 0.1, IEEE‑754 format, and how to avoid precision loss using BigDecimal in Java.
IEEE 754JavaJavaScript
0 likes · 9 min read

This article explains why adding 0.1 and 0.2 in JavaScript (and most other languages) does not yield exactly 0.3, covering binary representation of decimal fractions, IEEE‑754 precision limits, single‑ and double‑precision formats, and practical implications for developers.
IEEE 754JavaScriptbinary
0 likes · 10 min read

This article explains why JavaScript’s Number type suffers from floating‑point precision errors, describes the IEEE‑754 double‑precision storage format, clarifies key Number properties, shows why 0.1 + 0.2 is not exactly 0.3, and provides practical code‑based solutions.
IEEE 754JavaScriptcode
0 likes · 9 min read


ITPUBMay 27, 2017 · Fundamentals
The article explains why adding 0.1 and 0.2 in JavaScript, Python or C produces 0.30000000000000004 instead of 0.3, by detailing binary floating‑point representation, IEEE‑754 encoding, exponent alignment, rounding rules, and shows C code that reveals the exact stored bits.
C++IEEE 754JavaScript
0 likes · 11 min read
