I tried Julia again after some time using MATLAB. However, I cannot get debugging to work in VS Code. When I set a debug point, Julia pauses correctly, but when I remove the breakpoint, Julia will still pause at this breakpoint despite it does not exist anymore. This means debugging is completely unusable when I cannot remove a breakpoint at any time, such as when inside a big loop.
I visit Julia sometimes to see if it did improve, but debugging is the most central and important feature in a language built for scientific computing. Pausing and looking at variables is mandatory.
Why is debugging still so bad? How am I supposed to use any programming language without debugging? This is simply impossible. How do you program any logic without stepping through your code? I cannot believe that anyone can work productively without a good debugger.
Thank you. However, I have no idea how I should apply this fix. Is there a documentation somewhere? Or should I switch to a previous version of Julia? I am wondering why this hasn’t the utmost priority as Julia is basically fundamentally broken without a working debugger. How can anybody use Julia in this state at all? It is simply not possible.
Realistically you’ll have to wait until we publish a new version of the Julia VS Code extension. It will be in the next prerelease that comes out, but no promise when that will be
We are all mostly volunteers working on this stuff in our free time, and what is or isn’t a priority is also not centrally managed. Apart from this specific bug, the debugger in general in Julia needs a lot of work before it can be competitive with the experience one might have for other languages, just as a warning.
I don’t like the state of interactive GUI debugging for Julia any more than you do, but these aren’t true at all. As in this case, debuggers are generally third-party tools that have no bearing on the usability of the programming languages. There have even been serious arguments (that I mostly don’t agree with) against using stepping debuggers, and there are other ways to find bugs (which I do).
Thank you for pointing that out. However, I do not want to attack you in any form, but programming without a debugger is not an option. Sure there are other ways, but those are not acceptable in any form as they are slow and cumbersome. You simply cannot properly investigate the logical flow of events and state changes when you cannot move step by step through your code. Note that my reaction is not only based on this response but from several discussions here in this forum where for some reason many people believe that debugging is optional. I really like Julia conceptually but I cannot ever use it for anything more than toy problems if I cannot use it productively. I simply cannot believe that anybody thinks debugging through printf or other methods is a valid alternative. However, I get that this is may be a non-trivial problem and a lot of work for volunteers, so it is what it is.
Well, I personally need the debugger maybe 2–3 times a year and for the cases I need it it works absolutely fine for me (kudos to the devs!) – ok for now I never deactivated a breakpoint while running the debugger I think…
Otherwise I usually do a lot of mathematical tests and can read my code and see what it does without running them, so maybe your wording “no one can use this all at all” is a bit too strong. It might be what you require – personally or in your scenario – but believe me, I do use Julia very productively.
And sure, it would still be great to have a faster, better, … debugger. As it is with many tools. But that also requires more volunteers then. For that – I neither have the knowledge about debuggers as well as enough other voluntary packages I work on.
Maybe you want to enter volunteering?
Sharing a sincere opinion in a mild disagreement is not an attack, this is well within community standards. Bear in mind that other people claiming debuggers are optional were doing so as well, even if their arguments don’t sway you (or me).
Personally, I would love a reliable GUI debugger, but alternative ways to find bugs are valid and superior in many cases. I actually consider stepping to be one of the slower options; while ideal for smaller scripts or functions, the interpretation layer and a tendency to over-step in uncertainty can become a nightmare in longer algorithms. I tend to analyze my program in bulkier ways until I can isolate the problem to a small enough part that warrants more interaction, in which case I’ve been getting away with Infiltrator.jl. That however does not step into callees, which may not be statically inferred for me to examine separately, so again, a typical debugger would be great there.
