bryango

I really wish Mathematica would open-source the heuristics behind these core functions (including common mathematical functions, Simplify, Integrate, etc.). The documentation is good, but it still lags behind the actual implementation. It would be much easier if we could peek inside the black box.

You need to ask via API to make sure that there is no system prompt.

I hope we can have something that combines the meta-programming capabilities of Zig with the vast ecosystem, community and safety of Rust.

Looking at the language design, I really prefer Zig to Rust, but as an incompetent, amateur programmer, I couldn't write anything in Zig that's actually useful (or reliable), at least for now.

Funny that the url is https://www.busybox.net/kill_it_with_fire.txt

I don't think the author intends to provide a serious production solution, at least not for now.

     Runit tools in busybox - up to the task?

    Let's test busybox's runit applets in a hypothetical ;) scenario
    when someone needs to stop running, say, systemd on, say, a Fedora machine.

    No doubt this will expose various shortcomings.

To me, This just seems like a fun experiment to demonstrate busybox's capabilities.

> They do _not_ resolve the Hubble tension.

Thank you! They should have clarified this up front in the title or the abstract. The original article makes it sound like it has been resolved:

> (title) Webb & Hubble confirm Universe’s expansion rate

> (abstract) ... However, a persistent difference, called the Hubble Tension, is seen between the value of the constant measured with a wide range of independent distance indicators and its value predicted from the afterglow of the Big Bang. The NASA/ESA/CSA James Webb Space Telescope has confirmed that the Hubble Space Telescope’s keen eye was _right all along_ (emphasis mine), erasing any lingering doubt about Hubble’s measurements.

This feels like bad reporting to me. A better title would be "Webb confirms Hubble's measurement of Universe’s expansion rate", but that would probably be less exciting...

Hey! Thank you for this cool editor! However, has it been written with cross-platform support in mind? Otherwise, porting from mac to linux could be rather painful and time-consuming... Will there be an ETA for us linux users? I saw it on the roadmap [0] but without an ETA.

[0] https://zed.dev/roadmap

Ah, to be more precise, I work in high energy theory (hep-th): https://arxiv.org/archive/hep-th. I shouldn't have spoken for theoretical physics in general, but in hep-th, mathematica is basically a requirement (nowadays, can't say for 1987). I believe the same applies to high energy phenomenology (hep-ph) in which some fundamental packages (e.g. feyncalc) are written in mathematica.

These are all valid criticisms. There is no type system, although some safeguards can be implemented through pattern matching and conditions (see the answer by @derf_ above). For quick and dirty transforms on symbolic math expressions, these are often good enough, but it is indeed a mess to use as a full fledge programming language.

I do like that the lispy language itself closely mirrors math expressions, and it is consistently accessible throughout the user interface. For example, the mathematica notebook frontend (IDE) is simply some `MakeBoxes[]` of the expressions, which are all valid mathematica code themselves. I tried sympy a while ago, which I believe took an object-oriented approach, and it was very clumsy when compared to mathematica.

Still, I would not recommend using mathematica for general programming, precisely because of the mentioned shortcomings. By default, it is also impure and not lazy (eager eval, although it can be forced to be lazy on a case by case basis using `Hold` or `Unevaluated`).

Wolfram would like to say that he invented Mathematica all by himself, but in its core, it is basically a lisp: everything is an expression, and mathematics are just transformations of the expressions. Afaik this makes it the best tool (conceptually and practically) for generic symbolic manipulations. For example, `1 + 1` in Mathematica is just syntactic sugar for `Plus[1, 1]`, and `a = 1` is `Set[a, 1]`.

I am a PhD student in theoretical physics and almost everyone in our field has no choice but to use it (I do know one or two people that use maple, but the overwhelming majority chooses mathematica).

Despite its elegant design, many people hate it with a passion, as it has grown to be a huge bloated mess that takes forever to run. Also, due to the closed source nature, it is very hard to debug when something goes wrong. For example, it is quite often for the basic functions like `Simplify` and `Integrate` to get stuck running forever, but there is no way to keep track of the internal transformations that mathematica is doing, since everything is sealed up.