OneBug This week's bugs

Real bugs, explained.

Every write-up starts as a playable puzzle: find the bug first, then read why it bites in production and how to fix it for good.

JavaScript all JavaScript bugs

JavaScript async forEach does not wait (and returns 0) totalStock returned 0 while three warehouses were full. forEach never awaits the async callback it is handed, so the sum returns before a single fetch settles. The fix. Why 0.1 + 0.2 !== 0.3 in JavaScript (and the real fix) An invoice that should read settled comes back false: 0.1 + 0.2 is 0.30000000000000004, not 0.3. Why === fails on floats and how to compare them right. map(parseInt) returns NaN - the array index becomes radix map passes (value, index) and parseInt reads the index as a radix, so clean numeric strings come back NaN or wrong. Two safe ways to write it.

TypeScript

Array.sort() puts 110 before 25 - the default comparator trap JavaScript's Array.sort() without a comparator sorts numbers as strings, so 110 comes before 25. Why the default works that way, and the one-line fix. Array(n).fill([]) fills every slot with the same array Array(n).fill([]) looks like it builds n empty arrays, but fill() copies one reference into every slot, so every bucket mutates together. Here is the fix.

Python all Python bugs

Python lambda in loop returns the same value (late binding) Three handlers built in a loop all format the 503 label instead of 404, 500, 503. Python closures read the loop variable at call time. Here is the fix. Remove items from a list while iterating in Python (fix) Deleting matches inside a Python for loop skips elements - one pending task survives. Here is why the loop skips, and the one-line fix that works. Python class attribute shared between instances (list) A list defined in the class body is created once and shared by every instance - one object's append shows up in all of them. The fix is one line in __init__. Python dict assignment doesn't copy - it aliases the dict config = defaults binds a second name to the same dict, so an update() writes into your defaults. How to spot aliasing and copy a dict properly. Python is vs == on integers: True at 256, False at 1000 is compares identity, not value. CPython caches ints from -5 to 256, so small numbers pass an is-check by luck and bigger ones fail it. Use ==. Python mutable default argument: the list that never resets A default argument like applied=[] is created once, at import time, not per call, so every invocation that skips the argument shares and grows the same list. Python str.strip(".txt") strips characters, not a suffix filename.strip(".txt") strips a set of characters from both ends, not the suffix, so names lose extra letters. Here's the fix with removesuffix.

Go all Go bugs

Go len(string) counts bytes, not the characters you see len("cafe") with an accented e returns 5, not 4, so a four-character limit rejects a valid name. Go strings are UTF-8 bytes. Here is the rune-count fix. Go fatal error: concurrent map writes (and the fix) 500 goroutines wrote one map and Go killed the whole process - and recover() cannot save it. Why concurrent map writes are fatal, and how to fix them. Go: assignment to entry in nil map (why writes panic) Writing to a nil map panics in Go while reading it works fine. Here is why var makes a nil map, not an empty one, and the one-line make fix. Go closures capture variables, not values (1.22 or not) Every closure built in the loop returns the same final value, because they all share one captured variable. Why Go 1.22 didn't fix this shape. Go data race: 500 goroutines, a counter that loses count count++ is a read-modify-write, so unsynchronized goroutines overwrite each other's updates. Real -race output, the fix, and the fix that isn't. Go typed nil: err == nil is false after you returned nil Returning a nil *Error through the error interface makes err != nil true on success. Why Go interfaces carry a type, and the one-word fix. Go range loop doesn't update structs: the value-copy trap A Go range loop over a struct slice silently fails to update fields because it copies each element. Here is why, and the one-line index fix. Go slice bug: nums[:0] silently overwrites your input array Appending to a reslice like nums[:0] shares memory with the caller's array, so filtering silently corrupts the original data. Here's why, and the fix.

Java

Java binary search overflow: the bug that hid for 9 years Java's binary search threw ArrayIndexOutOfBoundsException on huge arrays for nine years: low + high silently overflows to a negative int before the divide. Java Integer == works until 128: the boxing cache trap Comparing boxed Integer with == in Java passes for small ids and fails above 127 because of the Integer cache. Why that happens, and the exact fix.

C

Signed/unsigned bounds check bypass: -1 becomes SIZE_MAX A bounds check casts size_t down to int, so the comparison runs signed: a negative length slides past the guard and turns memcpy's copy size into SIZE_MAX. malloc(strlen()) off-by-one: the heap overflow strcpy hides malloc(strlen(label)) allocates one byte short because strlen excludes the NUL terminator, so strcpy writes past the buffer. The fix and why it stays hidden.

SQL all SQL bugs

SQL integer division returns 0 instead of a decimal passed / total returned 0 for a student who passed three of four tests. SQL divides two integers as an integer and drops the remainder. Cast one side. SQL AVG ignores NULL: the average that reads too high AVG(discount) came back at 10 when the real average was 3.33. SQL aggregates skip NULLs, so no-coupon orders drop out of the math. Here is the fix. SQL != and <> exclude NULL rows (and how to fix it) A WHERE status <> 'shipped' filter quietly drops every row where status is NULL, so records vanish from the result. Here is why, and the fix. SQL COUNT(column) vs COUNT(*): why NULLs undercount COUNT(coupon_code) looked like it counted orders. It counts non-NULL coupons, so a customer with no coupons drops to zero. Here's the fix. LEFT JOIN with WHERE acts like INNER JOIN (missing rows) A WHERE filter on the right table's columns drops the NULL rows your LEFT JOIN just preserved. Why it happens and where the filter belongs. SQL join fan-out silently inflates SUM() totals An extra JOIN to a one-to-many table multiplies rows before SUM() runs, so revenue looks too high. The fix is dropping or pre-aggregating that join. SQL NOT IN returns nothing? Blame one NULL NOT IN (subquery) silently returns zero rows when the subquery contains a single NULL, because NULL comparisons evaluate to UNKNOWN. Here's the fix.