JavaScript

Last month I reviewed a bug where a checkout total sometimes doubled. The root cause was simple: one module wrote order.total in dollars while another treated it as cents. There was no guardrail, so the value ping-ponged until the UI showed nonsense. When I see this, I reach for getters and setters. They let me […]

The first time I built a workout tracker, I assumed the hardest part would be styling. The real challenge was time: starting, stopping, and showing numbers that never jumped backward. A stopwatch is tiny, but it forces you to deal with the same concerns as large apps: state, event wiring, and consistent rendering. With more

Last month I was debugging a payment bug, and my logs kept printing [object Object] where the amount should have been. That single string told me JavaScript had fallen back to the default object stringifier and had tossed away every useful field. The method behind it is Object.prototype.toString, and it lives on the prototype chain

Last month I chased a checkout bug that only appeared when a customer applied three coupons and switched tabs. The UI looked fine, yet the total kept jumping by a few dollars. I watched the logs scroll by and realized we were measuring the wrong state at the wrong time. That moment reminded me that

When I build a design system for a product, the hardest part isn‘t picking a single brand color; it‘s keeping every shade consistent as the UI grows. I‘ve watched teams ship buttons that feel ‘off‘ because someone tweaked RGB values by hand and the brightness drifted. HSV gives me a mental model I can trust:

Last week I was tracing a payment gateway bug where a checksum in the docs was shown as hex but my JavaScript logs were decimal. The bytes looked right, yet the mismatch left me stuck until I converted the numbers to hex and lined them up. That kind of mismatch happens all the time with

Last month I was wiring a dashboard where product metadata arrived as snakecase, kebab-case, and camelCase. The UI needed human labels like “Order Status” and “Fulfillment Type,” yet the backend only sent keys such as orderstatus and fulfillmentType. I could hand‑craft regex rules, but that ends up as brittle string plumbing scattered across the app.

Last quarter I was debugging a billing schedule that skipped a day in production. The root cause was tiny: a single delete on an array left an empty slot, and a later report loop quietly skipped it. That bug was not about fancy algorithms. It was about picking the right array method for the job.

Last month I shipped a checkout redesign that looked perfect on my laptop. A tester opened it on a mid-range Android and the primary button dropped below the fold. The root cause was simple: I treated the device screen width as if it were the visible browser area, but the address bar and safe-area insets

When I’m debugging a broken emoji in a chat app or a garbled log line from a service worker, the culprit is almost always the same: bytes were turned into text at the wrong time or in the wrong way. Modern web apps move raw data everywhere—fetch streams, WebSockets, file APIs, and cross‑thread messages. At

On a project last year, I had an offline-first mobile client, a web dashboard, and three backend services all creating records before they ever met each other. The only way to keep those records from colliding was to stamp each one with an identifier that could be generated anywhere, anytime. That is where GUIDs and

Last quarter I was wiring a checkout form that collected line items as a JavaScript array. The API accepted JSON text, not live objects. I passed the array straight into fetch and saw a 400 error. The array printed as [34, 24, 31, 48], so it looked like JSON. It wasn‘t. JSON is a string,