Skip to content
Tagged articles

IEEE 754

16 articles · Page 1 of 1
LuTiao Programming
LuTiao Programming
Nov 15, 2026 · Backend Development

Why Snowflake IDs Change in the Browser: JavaScript's 53-bit Integer Limit

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
Why Snowflake IDs Change in the Browser: JavaScript's 53-bit Integer Limit
JavaScript
JavaScript
Oct 17, 2026 · Fundamentals

Stop Using reduce for Sums: JavaScript's Math.sumPrecise() Explained

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
Stop Using reduce for Sums: JavaScript's Math.sumPrecise() Explained
AI Cyberspace
AI Cyberspace
Mar 29, 2025 · Fundamentals

Why FP32 Remains the Benchmark for Measuring AI Compute Power

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
Why FP32 Remains the Benchmark for Measuring AI Compute Power
IT Services Circle
IT Services Circle
Jun 14, 2024 · Fundamentals

Understanding Floating‑Point Precision and Common Pitfalls in Java

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
Understanding Floating‑Point Precision and Common Pitfalls in Java
Liangxu Linux
Liangxu Linux
May 24, 2023 · Fundamentals

Why 0.1 + 0.2 Gives 0.30000000000000004 – Inside 64‑bit Floating‑Point Math

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
Why 0.1 + 0.2 Gives 0.30000000000000004 – Inside 64‑bit Floating‑Point Math
ELab Team
ELab Team
Jul 14, 2022 · Frontend Development

Why JavaScript’s toFixed Fails at Precise Rounding and How to Fix It

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
Why JavaScript’s toFixed Fails at Precise Rounding and How to Fix It
Sensors Frontend
Sensors Frontend
May 24, 2022 · Frontend Development

Must‑Read Frontend Articles: CSS, JavaScript, React, WebAssembly & More

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
Must‑Read Frontend Articles: CSS, JavaScript, React, WebAssembly & More
Liangxu Linux
Liangxu Linux
Nov 4, 2020 · Fundamentals

Why 0.2 + 0.1 Equals 0.30000000000000004 in JavaScript and How IEEE‑754 Handles Decimal Fractions

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
Why 0.2 + 0.1 Equals 0.30000000000000004 in JavaScript and How IEEE‑754 Handles Decimal Fractions