121–130 of 141 posts
I love Rust for mathematical and scientific tasks (I am building the structural bio crate infrastructure), and I love Mathematica and have a personal sub. I should be the audience, but... What makes Mathematica great, IMO, is the polish and overall experience created by consistent work with applications in mind over decades. So, I look at this project with skepticism regarding its utility.
Half-assed reimplementations of existing software (often in the name of "memory safety") is what the Rust community is best known for.
Earlier quoted context omitted.
Mathematica is proprietary software. Any reimplementation is better than nothing at all, at least for people that don't run proprietary software
What's wrong with Maxima?
Earlier quoted context omitted.
Do you see why this perspective is a red flag on its own?
I certainly don't. If a software developer has found a way to use these tools that works well for them and produces good results, that's a good thing.
My Bona fides: I've written my own Mathematica clone at least twice, maybe three times. Each time I get it parsing expressions and doing basic math, getting to basic calculus. Then I look up the sheer cliff face in front of me and think better of the whole thing. There is an architectural flaw in Woxi that will sink it hard. Looking through the codebase things like polynomials are implemented in the rust code, not in…
Sorry, perhaps, a dumb question: Is it not that Mathematica, and most of the Wolfram innovation, is about a smart way of applying some rule-based inference. I think of it as parametrized PROLOG rules, with large lib. So term rewriting all the way to the end, correct me if I'm wrong. Where does the mini-core+JIT come into this? Thanks for taking time to answer.
Earlier quoted context omitted.
Since we can’t know whether they really hand-wrote the code, we also wouldn’t know whether they looked at it.
Err yeah that's the point.
But that’s not true, because even if they did indeed hand-write the code, we as third parties wouldn’t have any reliable proof of that, and therefore still couldn’t draw the conclusion that they looked at the code.
Them claiming to have hand-written the code isn’t any better than them claiming to have thoroughly reviewed the code. We can’t know in either case.
Earlier quoted context omitted.
Half-assed reimplementations of existing software (often in the name of "memory safety") is what the Rust community is best known for.
Mathematica is proprietary software. Any reimplementation is better than nothing at all, at least for people that don't run proprietary software
Earlier quoted context omitted.
Err yeah that's the point.
You wrote: “If they hand wrote the code we know they at least looked at it once.” But that’s not true, because even if they did indeed hand-write the code, we as third parties wouldn’t have any reliable proof of that, and therefore still couldn’t draw the conclusion that they looked at the code. Them claiming to have hand-written the code isn’t any better than them claiming to have thoroughly reviewed the code. We ca…
It is better, because most people aren't out-right liars. If he said "I hand-wrote the code", sure it doesn't prove it, but I would believe him. When he says "I thoroughly reviewed the code"... yeah maybe. That's the sort of thing people do lie about (even to themselves).
Earlier quoted context omitted.
Sorry, perhaps, a dumb question: Is it not that Mathematica, and most of the Wolfram innovation, is about a smart way of applying some rule-based inference. I think of it as parametrized PROLOG rules, with large lib. So term rewriting all the way to the end, correct me if I'm wrong. Where does the mini-core+JIT come into this? Thanks for taking time to answer.
The interpreter / JIT is the one actually applying the rules.
Earlier quoted context omitted.
What? Arbitrary precision arithmetic implemented in a compiled language will be faster than the alternative. This is no great mystery. The same is true of essentially all low-level symbolic or numerical math algorithms. You need to get to a fairly high level before this stops being true.
Of course. The point is whether you interpret a call to arbitrary_precision_add or compile the call doesn't matter much.