Chris Rackauckas, a computational scientist and Julia developer, writes about Julia, scientific machine learning, differential equations, and numerical computing.
HN commenters cite his posts on ChatGPT's Julia code quality and on chaos in AI for science, and recommend the blog generally.
You make a very good point. As PG says explains in [1], in a regime dominated by tail events, if most attempts are a moderate success (and no black swan successes), then the portfolio was probably too conservative.
On the other hand, due to limited resources, I get the feeling that most academics are operating in the risk-averse mode. See, for eg [2] -- it seems to be solid advice for succeeding in academia (I'd like to hear counterpoints to that from people who've had an extended/successful academic career), but it seems wholly focused on small predictable improvements.
I wonder whether this problem is a consequence of enforcing "accountability" in a regime dominated by fat tails.
Maybe we've picked up all the low-hanging fruit in research and we can only hope for slow incremental progress (which is what the management structure is set up to optimize), and we need to come to terms with that and stop wistful discussions about not having black swan successes.
[1]: http://paulgraham.com/swan.html
[2]: http://www.stochasticlifestyle.com/tips-google-summer-code-application/
Yeah, I'm just trying to point out, that not much would be won by that.
You either need to change the semantic of the language (CPython) or live with a slow JIT for some of the most used features of the language... And changing the semantic of the language is pretty terrible - it fragments your libraries introduces unbreakable borders prohibiting cross package optimizations and extensability, and much worse, CPython is now basically a language that combines the bad stuff of python and C ;) I know, that's a bit too cynical, but coming from a well designed language for JIT (Julia), that's how CPython starts looking to me. You will simply never reach the elegance of a language that was designed from scratch for this.
What I want to point out is, that the whole topic is bigger than "JIT my one slow function and make it fast"! A good read about this topic is:
http://www.stochasticlifestyle.com/why-numba-and-cython-are-not-substitutes-for-julia/
That's a good one. But there are so many I don't know which ones to send you. Any particular interests? Even on Google, if you search for specific keywords you will find such sites, maybe after the first few pages. I maintain my own site with no advertising or tracking, and no intrusive javascript, but I don't know if it would interest you.
Here are a few random selections from my RSS collection:
• https://www.justuseemail.com/
• https://apenwarr.ca/log/
• http://www.stochasticlifestyle.com
• https://jvns.ca
• https://www.math.columbia.edu/~woit/wordpress/
• https://www.futilitycloset.com
• https://retractionwatch.com
• http://vihart.com
• https://www.ex-muslim.org.uk
• https://tug.org
• https://lwn.net
• https://prometheus.med.utah.edu/~bwjones/
None of these have cookie warnings, doorslams, or other annoyances. I have a over a hundred of these. There is more out there than you could possibly keep up with, even with RSS.
Where I am people are really pushing out of the MATLAB/Python world into Julia. It's tailor made for scientific computing in a way that none of the others are.
Clearly we're talking decades, but I am already realizing pay-offs from the switch to Julia (from Python) in my domain.
Rackauckas pointed out an amazing example recently [1]:
https://discourse.julialang.org/t/differentialequations-jl-and-measurements-jl/6350
You have a library that implements calculating with numbers with uncertainties. You have the differential equations library. They don't know about each other but you can use the former in the latter to solve differential equations with uncertainties with a whole bunch of advanced solving algorithms.
This sort of power, having an ecosystem like Python that combines in a performant way, will be huge.
[1] http://www.stochasticlifestyle.com/why-numba-and-cython-are-not-substitutes-for-julia/
Speaking as someone who started in Java and moved to Julia, my experience has been that a lack of concrete subtyping has generally not made an impact on difficulty with respect to problem modeling (at least, not relative to Java or other languages with concrete subtyping). Moreover, some of the emergent properties of Julia’s type system (the “Tim Holy Trait Trick,” etc) enable problem modeling in different — and perhaps more “Julian” — ways, modeling by behavior rather than structure.
That said, if you absolutely need concrete subtyping in Julia, you can emulate it for structure with the tricks described in this (old but gold) Chris Rackauckas blog post: https://www.stochasticlifestyle.com/type-dispatch-design-post-object-oriented-programming-julia/
I usually use one instance, sometimes two. But this is a reasonable account of Chris Rackaukas using 32 instances at a time to do boilerplate maintenance across a bunch of open source repositories: https://www.stochasticlifestyle.com/claude-code-in-scientific-computing-experiences-maintaining-julias-sciml-infrastructure/
> I have had to spend like 4am-10am every morning Sunday through Saturday for the last 10 years on this stuff before the day gets started just to keep up on the “simple stuff” for the hundreds of repos I maintain. And this neverending chunk of “meh” stuff is exactly what it seems fit to do. So now I just let the 32 bots run wild on it and get straight to the real work, and it’s a gamechanger.