I have always anthropomorphized my computer as me to some extent. "I sent an email." "I browsed the web." Did I? Or did my computer do those things at my behest?

I think this is a relatively unique outlook and not one that is shared by most.

If you use a tool to automate sending emails, unrelated to LLMs, in most scenarios the behaviour on the receiver is different.

- If I get a mass email from a company and it's signed off from the CEO, I don't think the CEO personally emailed me. They may glanced over it and approved it, maybe not even that but they didn't "send an email". At best, one might think that "the company" sent an email.

- I randomly send my wife cute stickers on Telegram as a sort of show that I'm thinking of her. If I setup a script to do that at random intervals and she finds out, from her point of view I "didn't send them" and she would be justifiably upset.

I know this might be a difficult concept for many people that browse this forum, but the end product/result is not always the point. There are many parts of our lives and society in general that the act of personally doing something is the entire point.

Of course that's true, but (in the context of the GP) code's bespoke artisanal nature is not the one most people value.

I drove to the supermarket!

As a term-rewriting system the rule x-x=0 presumably won’t be in Simplify, it’ll be inside - (or Plus, actually). Instead I’d expect there to be strategies. Pick a strategy using a heuristic, push evaluation as far as it’ll go, pick a strategy, etc. But a lot of the work will be normal evaluation, not Simplify-specific.

Mathematica has Infix [0], which expresses the adjacency with a ~ (because Mathematica reserves pure blankspace for multiplication). But it works fine to do eg. `"hello"~StringJoin~" world"`; I was always surprised we could only have the predefined operators in many other languages and we couldn't define our own.

This seems like a great attempt. I would be worried about how much parsing and backtracking might be required to infer the infix precedence in a totally general system (like garden-path sentences[1]) or actually ambiguous parse trees (which is cured by adopting some rule like right precedence and parens, but what rule you pick makes some 'natural language' constructions work over others).

[0] https://reference.wolfram.com/language/ref/Infix.html

[1] https://en.wikipedia.org/wiki/Garden-path_sentence

Haskell supports user-defined operators (made up of symbols) and also lets you use functions in infix position by surrounding the name in backticks, e.g.

    2 `plus` 3

rather than

    plus 2 3

In Postgres you can define custom operators via `create operator`[0]

    -- infix
    select a <!!!> b;

    -- prefix
    select <||> a;

A lot of custom types end up using this [1].

    select @-@ '[(0,0),(1,0),(1,1)]'::path;
    -- 2

[0] https://www.postgresql.org/docs/current/sql-createoperator.h... [1] https://www.postgresql.org/docs/current/functions-geometry.h...

Similarly, Agda has a well-typed mixfix operator syntax – you define a function like (_foo_bar_baz) and can automatically write "X foo Y bar Z baz". It does mean that the operator parser has to be extensible at runtime, but it's not a huge cost for a dependently-typed language.

Mathematica has symbolic and infinite-precision addition, so you can't automatically take advantage of obvious compiled code.

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.

> The initial focus is to implement a subset of the Wolfram Language so that it can be used for CLI scripting and notebooks.

If you have Mathematica installed you can write CLI scripts and notebooks.

They did consider it, got a contract that affirmed that the military would be bound by the same pre-existing terms of service as every other user, and want to resist the military's pressure to renegotiate.

Surely that might be naive but the entire issue is that they want to stick to the original contract, which is of course the purpose of a contract in the first place.

IANAL but it seems 3rd-amendment-adjacent.

So far, this administration has wiped its ass with the constitution and... nothing happened.

I'm using these to teach an intermediate mechanics class, and my only regret is that there are no problems. The flip side is that sometimes Feynman skips over the derivations of certain things, and that makes good assignments ("Fill in the steps between [these assumptions] and [this result]").

Feynman's writing of course is stellar. The order is a bit unusual and not really designed for a "standard" university-level course. I can pick and choose, but I wish I could easily reorder the material.

There is a book of exercises, which I've heard of but not looked at myself, titled "Exercises for the Feynman Lectures on Physics". I don't know if that will help you but it might be worth a look.

I'll try to find it; thanks!

Looks like they're here:

https://www.feynmanlectures.caltech.edu/info/exercises.html

https://www.feynmanlectures.caltech.edu/flphandouts.html

“Pining for the fjords?”

> Winter rain, now tell me why

> Summers fade and roses die

> The answer came, the wind and rain

> [...]

> Circle songs and sands of time

> And seasons will end in tumbled rhyme

> And little change, the wind and rain

Fare thee well, Bob.