September 10th, 2024

Debugging in the Multiverse

Antithesis has launched a debugging tool that simulates a deterministic universe, allowing engineers to rewind time, capture system states, and explore past events to identify bug causes efficiently.

Read original articleLink Icon
CuriosityInterestSkepticism
Debugging in the Multiverse

Antithesis has introduced a new debugging tool that simulates a deterministic universe, allowing software engineers to effectively rewind time to investigate bugs and outages. This innovative approach enables users to capture the state of their systems just before a crash, facilitating the debugging process by allowing them to attach debuggers, capture network traffic, and analyze performance issues without the need to reproduce the original conditions. The tool also supports "multiverse debugging," where users can explore variations of past events to identify the root causes of bugs. This capability is enhanced by a browser-based reactive notebook interface that allows for immediate interaction with the simulated environment. Antithesis is rolling out this feature to existing customers, aiming to streamline the debugging process and reduce the costs associated with extensive logging and telemetry.

- Antithesis offers a time machine-like debugging tool for software engineers.

- The tool allows users to rewind time to investigate bugs and outages.

- It supports capturing system states, network traffic, and performance profiling.

- The "multiverse debugging" feature enables exploration of variations in past events.

- A reactive notebook interface enhances user interaction with the debugging process.

AI: What people are saying
The comments on the Antithesis debugging tool reveal several key themes and inquiries from the community.
  • Interest in technical comparisons with existing tools, such as King et al.'s time-traveling VMs and Qemu.
  • Questions about the tool's applicability in various programming environments, including node.js and its integration with build tools.
  • Curiosity about open-source alternatives and similar technologies like Qira and UndoDB.
  • Concerns regarding handling side effects and interactions with third-party systems during debugging.
  • Discussion on the challenges of deterministic debugging, particularly regarding non-bijective software states.
Link Icon 15 comments
By @casept - 4 months
Does anything like the Antithesis hypervisor exist as open source?

The closest I've seen is Qemu record/replay, but that's very slow (no KVM acceleration, no multicore), and broken in current Qemu versions (replayed system just gets stuck).

By @emeryberger - 4 months
Would love to hear a technical comparison between this and King et al.'s classic paper on Time-Traveling VMs from USENIX ATC 2006: "Debugging operating systems with time-traveling virtual machines" (https://www.usenix.org/legacy/events/usenix05/tech/general/k..., 505 citations).
By @mattgreenrocks - 4 months
It is really interesting to me that this sort of thing didn’t come from programming language folks like I’d expect. You’d think PLs are in the absolute perfect spot to implement things, because they define the semantics and runtime. And there are a few PLs who have time-travel demos, but they’ve never really been seen as more than a cool tech demo.

Perhaps the language is too small a vantage point to really get into what’s happening when debugging.

By @quickgist - 4 months
I've enjoyed reading many of the blog posts by Antithesis, really cool work.

I don't really see a fit for the automated testing product in our stack at the moment, but I would love to use a time traveling hypervisor that I can hop into whenever I'd like.

Currently, it seems your pricing is pretty focused on the automated testing service. Do you have pricing or plans that offer just the deterministic dev environment?

By @ripped_britches - 4 months
How do you handle side effects that interact with third party systems? In my own tests, I use network request mocks. Do you need to provide a test mode flag to indicate that mocks should be used?
By @grumbelbart - 4 months
I was once working in a company producing software / operating systems for smart cards (such as the chips on your credit cards). We developed a simulator for the hardware that logged all changes to registers, memory and other states in a very large ring buffer, allowing us to undo / step backwards through code. With RAM being large, those chips being slow, and some snapshotting, we were usually able to undo back to the reset of the card. That was a game changer regarding debugging the OS.
By @gguergabo - 4 months
Antithesis employee here. Happy to jump in and answer any burning questions people might have about multiverse debugging.
By @vngzs - 4 months
There's a binary analysis time travel debugger similar to this, Qira [0][1].

[0]: https://www.usenix.org/conference/enigma2016/conference-prog...

[1]: https://qira.me/

By @vikR0001 - 4 months
This looks very interesting! Is it possible to implement this in a node.js web app? Does it work with any build tool? How much latency does it add to a production server?
By @1970-01-01 - 4 months
>Seems obvious enough. But maybe, just maybe, the brake lines were cut by somebody who wanted the driver dead. Or what if he was drugged? Can we distinguish that scenario from him being sleepy?

If this is prod, your job is going to be finding what combination of these things caused it this time.

By @nynx - 4 months
Pretty much no software, even when run deterministically, is bijective. There are almost always cases where two different states map to the same state.

How does this tooling deal with that?

By @shoggouth - 4 months
Is this like UndoDB[0]?

[0]: https://undo.io/products/udb/

By @bluelightning2k - 4 months
I know I'm taking the wrong thing from this - but I really struggle to read this site. Something about the contrast and aggro gradients.
By @__0x01 - 4 months
Is this designed to be run in production?