8 ms·
Predictive Debugging: A Game-Changing Look into the Future
- seeknotfind 3y agoCool idea. Guess we are still having innovations without LLM
- invalidname 3y agoThat's pretty fantastic! When will this be available in Idea?
- thelazyone 3y agoSounds like a logical step forward from current debuggers! I had some colleagues who bragged of not needing debuggers for their workflow... Well, sometimes I really do.
- sanitycheck 3y agoIt does look very nice, but as with all fancy debugger features I wonder if I'd spend more of my life debugging the debugger when it doesn't debug than it'd save me. I also think that while a debugger is a great and useful tool, being able to debug without one is a requirement, because sometimes you don't have one (or it stopped working properly - see recent Android Studio releases) and if one can't do it just using logs one is really stuck. So it's worth getting practice at that.
- paulcjh 3y agoActivating type checking mode in VSCode was a game changer for me when running python, help catch loads of the edge cases for correctly for some production code
- mdaniel 3y agoIf you think turning on typechecking was a game changer, I can't wait to see the look on your face while using the more intelligent editor PyCharm; the kinds of things in catches are asymptotically magic
- jamesmurdza 3y agoIt looks like a combination of static analysis and live execution of what they call "pure" parts of the code, i.e. code that doesn't affect state outside the current function.
- RunSet 3y agoFriendly suggestion to peruse Jetbrain's third-party data-sharing agreement while considering what information of a user, even in theory, it might forbid them to share with anyone they wish for any reason they please. https://www.jetbrains.com/legal/docs/privacy/third-parties/ https://www.jetbrains.com/legal/docs/privacy/third-parties/ After you do that here are some IDEs that (so far as I know) don't have data-sharing agreements with third parties. https://downloads.codelite.org/ https://downloads.codelite.org/ https://vscodium.com/ https://vscodium.com/
- Bjartr 3y agoNothing listed there is anything particularly problematic so far as I can see. Can you be more specific? If you're saying that it's sufficiently vague as to not actually limit them in any way, then I'm wondering what a better privacy policy would look like. One that gives them proper leeway for the legitimate day-to-day workings of a company, but which manages to not be just as vague. One thing worth remembering here is that the alternatives you mention are exclusively IDEs, whereas the JetBrains privacy policy covers the data sharing they do for their whole ecosystem of products and services, not just their IDEs.
- WhereIsTheTruth 3y agoInteresting that you didn't even mention their opensource community edition: https://github.com/JetBrains/intellij-community https://github.com/JetBrains/intellij-community wich powers plenty of other open source IDEs, yet you push vscodium Nice FUD ;)
- krono 3y agoWhich also seems to be covered by the same privacy policy. That FUD accusation was a bit premature. For the record I dislike both vendors' products equally as much :) https://github.com/JetBrains/intellij-community/blob/60f8208092d13426de11954934f6eff3383c21d6/platform/platform-resources/src/PrivacyPolicy.html https://github.com/JetBrains/intellij-community/blob/60f8208...
- deleted 3y ago
- daxfohl 3y agoSeems almost like a spreadsheet once you hit a breakpoint. Pretty cool!
- hackinthebochs 3y agoNice to see something like this finally being made. I always wondered why I couldn't just annotate the value of variables and then have the IDE evaluate the code as I write it to show how those variables are mutated. Always seemed like low-hanging fruit. It would also have the benefit of being a learning tool to help develop a mental model of how coding works.
- vaughan 3y agoSomeone needs to design a programming language and an IDE (and possibly a new OS too) with great debugging as the primary goal. Debugger and IDE support is always just thrown on later in every new language these days. "Omniscient debugging" as seen in https://pernos.co/ https://pernos.co/ is the holy grail. Time-travel debugging would also be great. People are far too obsessed with static type checking. A lot of this time would be better spent invested in live debugging tools. When I'm editing my code I want to see exactly what _value_ each variable contains, the type really doesn't matter so much. Wallaby.js/Console.ninja is a great example of this. Good debugging, especially deterministic record/replay is usually complicated by the OS. I often wonder what an OS would look like if designed with debugging as a top priority.
- shardullavekar 3y agoWe started off as a time travel debugger for Java coders and failed to gain any traction. (our hn launch: https://news.ycombinator.com/item?id=31286126 https://news.ycombinator.com/item?id=31286126) Pivoted to record and replay. Developers can put assertion + mocking around the replay. We are working on a feature that shows what _value_ each variable contains. Check unlogged.io Disclaimer : I am the founder
- Bootstrapper909 3y agoVery cool! Any specific reason you started with Java?
- shardullavekar 3y agotime travel debugger for Java, since we worked in financial domain where Java was predominant. We couldn't debug on remote machines for the lack of access. We had to log a lot and it felt like guesswork. Having a debugger with a back button made a lot of sense. We logged everything by default and reverse mapped it with the code, so that we could reverse-F8.
- wiz21c 3y agopretty neat. But what I need the most right now is a way to visualize information. I work on computer fluid dynamics and there I have: - super intricate algorithms with lots of variables running around - lots of huge numpy arrays storing the bulk of the data I find the current debuggers lacking here: - showing numpy arrays in colours, easily changing color scales, etc. is not easy (you can do your own visualization, but then it's code); explore specific parts of the array in detail; link that to other arrays, etc. - build watches panels where you can mix analysis and values extracted from code. I can't count the number of time I freeze the execution, export data to R, then do analysis there, then fix the code. It'd be nice to have that integrated in the IDE. - have watches that record values as execution runs (I guess that's one of the stuff omniscient debugging does) And while I'm at it: - why can't I cut paste formulas, pictures, etc. in my code ?? (no Jupyter, you're ok for a nice paper like presentation but not for code with hundreds of thousands of lines)
- avidphantasm 3y agoLooks cool. I could do without the cutesy meme images.
- unshavedyak 3y agoHas JetBrains ever discussed putting out some sort of generic LSP oriented product(s)? I own a couple JetBrains product for very select things but as much as i enjoy the company i will never use them for my actual code.. because i'm a 20 year addict of Terminal based editors (currently on Helix). I'd love to see the considerable effort they put towards tooling available to the Terminal oriented audiences. Yea, probably small audience.. but i just often see this stuff and think "What if this was an LSP? I'd purchase it in a heartbeat!" Especially since multi-LSP editing is apparently viable. Eg Helix supports multiple LSPs for a single context, now. Though i'm not clear on the specifics yet, as i've not tried it yet. I really want to give them more money. I just don't want to use their UIs for my code.
- xpe 3y agoHello, I am an LSP bot designed to help clarify human language interaction. The above commenter used the term LSP without defining it. LSP means "Language Server Protocol." ~ Your friendly neighborhood Hacker News LSP Bot
- xpe 3y agoHow might a Language Server Protocol (LSP) work for debugging? And predictive debugging in particular? Any examples you've seen? Do LSPs have a mechanism by which debugging could work? (I haven't researched this yet.) Note: I ask the above questions in an attempt to move the conversation towards predictive debugging. Like many, I visited this thread because I'm interested in the core topic: debugging. We're probably not here for a general discussion about the pros and cons of JetBrains / non open-source software / IDEs.
- deleted 3y ago[deleted]
- Groxx 3y agoThe LSP version of debuggers is essentially DAP, and it is gaining some support: https://microsoft.github.io/debug-adapter-protocol/ https://microsoft.github.io/debug-adapter-protocol/ Like LSP it's a bit crippled compared to a normal debugger, but the universally-pluggable aspect is compelling.
- xpe 3y agoReading the title, my mind conjured what I consider to be the utopia of debugging: a probabilistic assessment of likely failure points across the entire stack, backed by reasoning over the relationships between the components. From there, generate a prioritized actionable debugging task list. An example might be "test input X on function Y so we can rule out Z". (Aside: The "so we can" part is the key to focusing the effort, otherwise debugging can turn into a technical-debt paydown-party. There is a time and place for that, but maybe not while your service grinds to a halt for unknown reasons.) Therefore, you can imagine why reading the article was extremely disappointing. No offense, JetBrains; this is still probably pretty good. Certainly a step in the right direction. And it is predictive debugging on a local scale. Context: I guess you could say I'm a harsh critic of the comically inane ways that debugging often happens. Often debugging happens at the worst time: when a person's cognitive capabilities are drained and stress is maximum. This is not the set of conditions we want. Debugging is quite different than designing. Mental flexibility and triage is key.
- Calzifer 3y agoNot very convinced yet. I would expect it to fail/not work quite quickly for cases which are "worth" debugging. For the first example I would just place the breakpoint on the return. The highlighting is quite nice but I see not much need for the prediction which was probably hard to implement. In languages like Java features like "hot code replace" exist. In a function like this if the result is not what I expect, I can simply change the code and restart the function without restarting the application. Not much need for prediction. What I wished were more common is reverse debugging were you can step backwards.
- yodon 3y agoWow. Your description of Time Travel Debugging plus Edit and Continue working together sounds amazing. Definitely want to try that some day. I suspect the side-effect/impure-function-call detection JetBrains has built here will be key to understanding boundaries of where/when you can roll back, edit, and continue, and where/when you can't.
- matkoch 3y agoDid you see the part about live edits? Placing the breakpoint at the return would be too late to have that working. Edit: or maybe that was your point after all?!
- deleted 3y ago[deleted]
- jerrygoyal 3y agoa version of this already exists in VSCode but you need to enable it from settings
- Xeamek 3y agoDon't know if this will be "game-changing", but definitely a nice to have QoL
- Bootstrapper909 3y agoVery neat! Generally speaking, it seems like testing and debugging, hasn't been getting as much love as other aspects of computer programmeing. Debuggers still work pretty much the same as gdb, only now with an integrated UI, and there's so much room for improvement. This is a great start and can be taken much further with abilities to mimic complete sessions to easily reproduce bugs and run them again and again until fixed. We see the same at the related testing automation field (disclaimer - checksum.ai founder). Same testing methods, same testing problems, only fancier packages.
- GuB-42 3y agoTesting gets a lot of love, at least in theory. Much less in practice because it is a whole lot of extra work. As for checksum.ai, is it some kind of fuzzer? I think fuzz-testing is under utilized, in fact, many of my colleagues don't even know that it exists, and I have never been on a project where it was done. Generally, fuzzing is done in the context of security, but I see no reason why it should be limited to it.
- shyamkumar7 3y agoNot exactly (disclaimer - on the checksum team). Our goal is to generate end to end tests that mimic user behavior, using real production sessions to train our models. These end to end tests could then be run during development, effectively smoking out real potential bugs before your latest deployment makes it into production. Of course, part of the generated tests could involve fuzz testing if it makes sense (if there is a form field, input, etc.)
- nathants 3y agoprintf and fast iteration are all that’s needed. golang got that much right. my pace on clojure and my pace on go are the same. the vibes are different though. my current 20s iterations with cpp are not great.
- Noumenon72 3y agoSounds awesome, but I never get to use PyCharm's debugger any more because all our tests run in VS Code devcontainer with a docker-compose full of helper containers like databases.
- Aaron2222 3y agoJetBrains recently added devcontainer support to their IDEs[0]. Not something I've had a chance to try out though. [0]: https://plugins.jetbrains.com/plugin/21962-dev-containers https://plugins.jetbrains.com/plugin/21962-dev-containers