disentanglement

I could perhaps get myself to care just the tiniest bit if the information that was supposedly stolen wasn't generated by "stealing" from everybody else. Either it is fair use to train AI models on whatever information you can get your hands on for everyone or for no one.

Electric semi trucks have appeared from all major European manufacturers in the last years and I expect them to become dominant even quicker than electric cars on simple cost grounds. Electricity is cheaper than diesel and due to favorable regulations in Europe, for many use cases there is little to no time lost charging and usually also no loss in load capacity.

You can find the whole integration routine here https://github.com/ad-si/Woxi/blob/36343ab2cbc97e5081f7c811e.... It's essentially a test mock-up (not even trying partial fraction decomposition for rational functions).

Fully agreed. I have never seen a programming language which is so badly designed as Wolfram. I really wish there was another way to access all of Mathematica's functionality with a more sane interface.

Did you really just attribute the deaths from a bombing raid on a dam during WW2 to a hydropower incident?

TeX is written in a literate programming style which is more akin to a math textbook than ordinary computer code, except with code blocks instead of equations. The actual programming language in the code blocks and the OS it runs on matters a lot less than in usual code where at best you get a few sparse comments. Avoiding bit rot in such a program is a very manageable task. In fact, iirc the code blocks which end up getting compiled and executed for TeX have been ported from Pascal to C at some point without introducing any new bugs.

Yeah, I'm not saying it's a good idea. But you could do it if you wanted to.

A 1 MWh battery isn't actually that big. There's electric trucks on the market right now with 600 kWh batteries sitting on the frame between the front and rear axle. That would easily fit into a basement room.

They are cheaper to run almost everywhere (depending on the cost of electricity versus gas of course). No breakthrough in battery technology needed for that.

I have never seen a conductor on a metro/subway system in Europe. Mainline trains often have one, but not always. I've ridden trains on small branch lines in Germany which were operated by a driver only.

Range is somewhere between 350 and 600 km depending on conditions. Aerodynamics, weight, weather all have an influence as well as the battery size and efficiency of the specific model of truck. The guy on the youtube channel has driven most of the selection of currently available long haul electric trucks in Europe under a variety of conditions, so this seems fairly representative.

The trucks are all designed to be driven for the legally mandated maximum of 4.5 hours at highway speeds and to be recharged sufficiently in a 45 minute break to be able to do that again for another 4.5 hours. In particularly adverse conditions a little less driving time before recharging is possible but for an average load the currently available tech works just fine and it is mostly the charging infrastructure that limits adoption.

I'd love to see the system of mathematics where 4 times 365 comes out to one million. Maybe I can get my bank to use the same system.

Well hopefully the starter kit doesn't include a few kilograms of weapons grade plutonium.

Although that paper even made it to PRL. I guess I should have written up some similar nonsense and sent it to PRL, might have improved my career chances.

> However, "macros" are a disaster to debug in every language that they appear.

I have only used proper macros in Common Lisp, but at least there they are developed and debugged just like any other function. You call `macroexpand` in the repl to see the output of the macro and if there's an error you automatically get thrown in the same debugger that you use to debug other functions.

As far as I know, optimization levels higher than -O0 work fine with SpillPointers. But at least in a cursory first look I had a while ago, the optimizations made things slower overall. I guess they might lead actually to more "moving pointers in and out of the heap" since the SpillPointers pass is done at the very end. But this should all be investigated more thoroughly.

Apart from the restriction to bytecode interpretation already mentioned, one reason for the slowness is that the sort of C with garbage collection that ECL needs is quite difficult to do in Webassembly. There is no way to scan previous stack frames for pointers in wasm, so all pointers to heap objects (or everything that looks like it might be one) have to be kept around somewhere in the heap where the GC can find them. This is really expensive and slows down the code a lot.

Of course, another approach would be to use the new wasm GC interface. But that requires defining a new ABI for garbage collected C, writing a new backend for LLVM, etc. So that would also be a lot of work to implement. Right now, there just is no efficient way to run programs that depend on bdwgc on wasm.

In lisp, macros are just ordinary functions whose input and output is an AST. So you can debug them as you would any other function, by tracing, print debugging, unit tests or even stepping through them in a debugger.

Or perhaps the republican party has developed such an astonishing anti-science attitude that hardly any reasonable scientist can support them? Imagine doing research on vaccines and hearing the soon to be secretary of health speak on that topic. As long as these kind of people count as "conservatives" in the US, how could you be a conservative scientist?

> For one thing, just admitting more people almost certainly decreases the access to quality education overall

Why would that be the case? There are many much larger universities all around the globe and also in the US that manage to provide quality education to their students.

To me, the statements that colleges make about their admission procedures always seem hypocritical to me. The colleges claim that the goal is to advance gender equality and provide education to underrepresented groups (which would not require a small student body) when their main goal seems to be in fact to create a small in-group of people who have made the right connections during their studies (which absolutely does require a small student body).

Coming from a country where the sort of super selective universities like Caltech don't exist, the fierce debates about equality of admissions to these sort of places never made sense to me.

If Caltech, Harvard, MIT or wherever really were committed about advancing gender inequality, why not just raise the numbers of students and admit more people? The number of students is mainly limited artificially and there's no reason they can't educate both men and women who apply.

Thermodynamics is usually (and rightfully so) taught together with statistical physics for which quantum mechanics is essential, so the order does make sense.

> cut all funding, regularly jail them, condemn them to obscurity

I can't even begin to describe how overjoyed I am to finally have found a fellow campaigner for implementing the glorious techniques of Maoist China in dealing with free thought.

The wormhole in this paper is actually in flat space. The geometry only approximates to an AdS geometry times a sphere close to the event horizons.

> Unless of course by "quantum theory" Maldacena actually means "string theory" or "AdS/CFT" – which wouldn't surprise me at all.

The wormhole solutions from the paper are semi-classical: they are obtained by taking the expectations value of the energy configuration of a quantum theory and feeding that into the classical Einstein equations. Therefore, no string theory or AdS/CFT is needed for the construction.

Your comment calling political measures which are universally accepted across the entire range of politics in Europe (state healthcare, universal education, ...) authoritarian marxist is a hilarious example of what the top poster meant by "the Overton Window is so far right even the Democratic Party is center-right".

> I claim any semantics which resulted in `11` would be extremely confusing, because it would imply the following also resulting in `11`, which is obvious nonsense:

> y = 10; > Module[{y}, 1+y]

Yes that is precisely the point: because of Mathematicas weird evaluation model, you cannot have ordinary lexical scope as in every other programming language, but the only sensible thing to do is to rename variables under the hood. It is then very easy to leak those renamed variables accidentally in the global scope where you cannot do anything useful with them, because the symbols `y` in the global scope and in the subscope are different.

Another point that the example was meant to illustrate is that once you assign some value to a variable, you can no longer do symbolic manipulation with it (note that in the example, we have replaced 1 by 10 in the end).

The main issue with the evaluation rules is that Mathematica doesn't distinguish between creating a symbolic expression and evaluating code. That is if I type

  f[x]

and the function `f` is not defined, Mathematica will not give me an error but instead just assume that I meant to create a symbolic expression. If you know some Lisp, just imagine that everything came with an implicit `quote` which would automatically get invoked whenever a unbound variable or function would we encountered.

That issue alone has caused me so many errors simply from mistyping some function or variable name. For simple expressions, such bugs are pretty obvious to spot but if the same occurs deep inside a chain of function calls, this often lead to completely wrong results because the bug got masked by some other manipulations I did on the result of the function call.

Of course, there are tons of hacks and ad-hoc workarounds in Mathematica to get around this (imho fundamentally broken) behaviour to the tune of "just stick another `Evaluate` here" or "just change the function definition from `g[x_]` to `g[x_?NumericQ]` to call the function only when the argument is numeric and otherwise leave it unevaluated".

The situation with the scoping rules is not much better. Consider for instance the following code:

  y = 1;
  expression = Module[{y},1+y]; (* Module creates a new scope in which y is unbound *)

Can you guess what happens if I print out `expression` now?

  Print[expression]
  1+y$4066

Yes, Mathematica has just renamed our variable. If now we wanted to set `y` in our expression to some concrete value, of course the obvious thing to try doesn't work, but just gives me some bullshit:

  Print[ReplaceAll[expression, y->10]]
  10+y$4066

These are all only some simple examples of why doing any kind of metaprogramming in Mathematica just sucks.

Perhaps I can add a counterpoint before anybody gets too excited and spends too much money on a tool they might not enjoy.

Having used Mathematica quite a bit for doing symbolic computation, my opinion on it is pretty much opposite to yours. While the extensive standard library is certainly nice, I think that the programming language used to access it is one of the worst programming languages in the world - certainly the worst I have ever used. I have never seen any other programming language where the basic scoping and evaluation rules are so badly designed and error-prone as in Mathematica.