gdb-dashboard VS lldb-mi

To debug, termdebug is built in to vim and supports a front end to gdb. In combination with gdb-dashboard this gives a reasonably good debugging experience

https://github.com/cyrus-and/gdb-dashboard, https://github.com/cyrus-and/gdb-dashboard/wiki

You can use the Python API to GDB to get really fancy TUIs like this: https://github.com/cyrus-and/gdb-dashboard

Try GDB Dashboard, it makes gdb much easier to use:

https://github.com/cyrus-and/gdb-dashboard

There's also Voltron which works with both gdb and lldb (amongst others):

https://github.com/snare/voltron

I can't believe no one has mentioned `gdb-dashboard` [1] yet! I use it extensively. [2]

Beyond that, I have recently learned how to write custom pretty printers for GDB. This saves a lot of screen space. I should probably update [2] soon with those new techniques.

GDB is powerful, useful, and after getting my start in IDE debuggers, including Visual Studio, I struggle whenever I have to go back.

[1]: https://github.com/cyrus-and/gdb-dashboard

[2]: https://gavinhoward.com/2020/12/my-development-environment-a...

Debugging: Learn gdb. You can use it for assembly. You can use it for C on a MCU. You can use it for Go on a Linux system. It’s ubiquitous, versatile, and worth understanding. You can pretty-print the output with something like this to help you out at first. There are 2 things you need, however: on chip debugger and a debug probe (though you don’t need an expensive one). Effectively, you talk to GDB, GDB talks to the server exposed by OCD, OCD knows the debug probe protocol, and the debug probe can use the MCU debug peripheral via SWD or JTAG to get those details.

I use gdb because I'm usually in the terminal. I don't think terminal it's any faster though. This is a nice addition to boring old terminal gdb.

When using a debugger such as gdb or lldb, typically you:

I'm on the record of loving the VSCode experience with Rust. And I do think that it's amazing that a "non-IDE" can feel so much like an IDE. However, I've recently pivoted off of that stance. I know it's still in EAP, but Rust Rover gives me all of the things that I get from VSCode plus an easier integration with LLDB.

Fortunately, we can use this same technique with our Node.js applications! This is possible through llnode: a LLDB plugin which enables us to inspect Node.js core dumps. With llnode, we can inspect objects in the memory and look at the complete backtrace of the program, including native (C++) frames and JavaScript frames. It can be used on a running Node.js application or through a core dump.

An alternative to gdb is lldb. But I like gdb.

The CMake-based, itk-wasm build system tooling enables the same C++ build system configuration and code to be reused when building a native system binary or a WebAssembly binary. As a result, native binary debugging tools, such as GDB, LLDB, or the Visual Studio debugger can be utilized.

The debugger component of the LLVM project. It’s what you’re typing into when you type po someExpression. https://lldb.llvm.org/ Web searches could help explain a lot of this for you 😊

If you really don't want to touch Visual Studio/MSVC then you can try to compile with clang and use lldb: https://lldb.llvm.org/

LLDB - https://lldb.llvm.org/ - Debugger from the LLVM project

Well, there's LLDB (https://lldb.llvm.org/) - I've heard it's got some nifty architectural features (e.g. having access to the Clang framework for handling C/C++ expressions).

I've done some minimal poking about in the code; I found its object-orientation a bit hard to grok (just for me personally) but it seemed to be quite uniformly applied so it might well be easier to work with.

The article does mention lldb as a future target.