Issue #19988 has been updated by rubyFeedback (robert heiler). Assuming the above is real - of which I am unsure - I believe this would fit more into the line of "add-ons", e. g. rubocop or other means to analyse software. Other than that I don't think MRI will go "AI style"; the philosophy of Ruby focuses more on the human being at hand. (It's also hard to evaluate the above when there are no real proof-of-concepts shown.) ---------------------------------------- Feature #19988: AI for inner code behavior analysis at runtime https://bugs.ruby-lang.org/issues/19988#change-105160 * Author: horv77@protonmail.com (Andras Horvath) * Status: Open * Priority: Normal ---------------------------------------- Dear Devs, I've been using Ruby extensively in my work and sometimes I use AI algos to debug inner workings of complex code loops. I wanted to send you the idea because I believe it is very easy to add the following functionality to Ruby and Ruby could be the first programming language ever from the mainstream ones to apply smart AI decisions internally. It could give Ruby a huge marketing power as well with all its advantages. So what is the idea that I already use sometimes to help my development? When I consider some part of the code, it usually involves manipulating many variables in a complex way. And my very simple idea is to get all variables analyzed automatically with an unsupervised, multivariable anomaly detection algo continuously. So when I run it on the variables inside an inner loop or structure, then the AI might be able to spot weird combinations of variable states that may be important to notify the developer of. The language may give a warning about these states or even jump to the entry using binding.irb. Anomaly detection works like when you have an N dimensional array, then every entry is analyzed and the most weird ones can be "spotted" (by showing their indexes of their positions in the array for instance). That's it. The fastest algo could be used for this. It is ISOLATION FOREST. It runs in quasi linear time. So if the user would enable this option at a particular line of code, then the Ruby interpreter would store all variables in an array on every run and would analyze it with the AD algo from time to time (because it takes time). It wouldn't have to analyze at every run because once the anomalous variables combinations get into the array, then they can be found later at any time. If the variable is not numeric (since all AI algo need numeric inputs), then a "text conversion to numeric vector" could be done. I've got a solution for that too. That is also very sophisticated and would boost Ruby's capabilities a lot IMHO. So a very sophisticated inner semantic AI analysis could take place with this option, which is very straightforward and easy to implement. The same could be applied for the behavior analysis of the memory usage. Many concaptual bugs could be tackled with such methods. It would be straightforward to do that from the interpreter side. I'd gladly provide the solution of the AI part. Thanks. Andras -- https://bugs.ruby-lang.org/