--------------------- BEWARE ---------------------c[ode]clap is currently in pre-alpha state. If you are expecting a software that has all the features you want in everyday use, please wait and return in a few months. If you want to try out this project as soon as possible, break it, give feedback and shape future goals, then you probably want to stay and read further.
Why this project?
Linux is a great ecosystem to compile code on. There is fast access to multiple good compilers. Most distributions provide a packaging system and repositories with lots of precompiled libraries and if you have to compile code yourself it usually works without too much a hassle.
Debugging on the other hand isn't such a pleasant experience, especially when compared to solutions available on Windows systems. Many tools struggle to give you a good view on what is actually happening with your data and the control flow, some suffer under their own interface clutter and others are build on some strange Java framework and are just slow and unresponsive.
codeclap goes back to the roots and tries to build a minimal foundation to show and understand what is going on when the compiled code is executed, why it is doing what it is doing and how it reached the state you may observe at that time.
I will consider this project to have reached alpha stage as soon as it potentially contains all features that people might want or expect from a debugger in everyday use. I've compiled a small list of those features that are currently missing completely:
- conditional and memory breakpoints
- out-of-process debugging (also attach and remote debugging)
- customizable keybindings (and more customization options)
- casts and function calls in watch window
- inlined functions are not handled very well in source view
- better C++ support (inheritance, possibly pretty-printing of STL structures)
What happens after reaching "alpha" state?
First of all, this page will get a totally cool and awesome introductory video. But at some point for a software project it is also necessary to mature and build a stable foundation. It is important that adding features, extending and changing existing features doesn't break the project all the time.
But at the same time this project has high ambitions to not only replicate the debugging experience you would expect from other systems but to make the interface as efficient as possible, provide better tools to quickly understand bugs or find them in the first place and observe how memory/variables get changed over time. Therefore after reaching alpha functionality I will likely aim for a state I will label as beta which may then become the first stable release; or I will go totally crazy and head towards "gamma" builds. However there is no stated time frame in which this may happen. Likely as soon as possible.
How does it look?