falkaer

Those new language constructs are exactly what's enabling the performance gains, by giving reliable information to the compiler. Projects like numba have clearly demonstrated the limitations of trying to compile pure Python.

It's only closed-source for now, with plans to open-source the language when it's more finalized - similar to LLVM early on. Not sure if it says so explicitly on their website somewhere, but Chris Lattner has stated that several times

I use the dwindle layout which is similar to bspwm in automatic splitting mode. One advantage is you can drag and drop windows into other nodes, which will be split appropriately, it's surprisingly neat when you have a lot of stuff open. It's easiest to get a feel for the differences by just trying it out or watching some videos of it on r/unixporn

I'm curious, why not use LLVM?

The M1 (laptops) do emulate x86, and the M1 (chip) has a few x86 specific instructions to improve emulation performance

I used this blog post as the basis for a small library to control my own closely related LB130 lightbulbs from the command line a while ago[0], works like a charm.

[0]: https://github.com/falkaer/tplink-lb130-api

With PyCharm I've managed to hide every single part of the UI besides the editor itself (I only had to get one plugin for the last bit, main menu toggler) and just use keybinds to show parts as I need them, so it's definitely a problem you can solve if you like

You are given money (5.435 dkk monthly after tax) for attending university in Denmark and pay no tuition. This is in stark contrast to most other countries.

How unfair indeed of them to release the model as open source with an accompanying freely available paper explaining all the details of it

If the solution program is sufficiently complex (as one would imagine it to be in non-trivial cases where we use AI, e.g. computer vision, speech synthesis, etc.), what makes you think the solution program is going to be more lightweight than running inference on an "AI model"? Futhermore, what guarantee do you have that the discovered solution is going to be efficient w.r.t. computation at all?

Python defines += as the __iadd__ method which is sometimes mutating, i.e. if the object being assigned to is mutable or not.

By far the most interesting part of this release is the new multi-threading features, I recommend reading https://julialang.org/blog/2019/07/multithreading for an overview, and watching https://www.youtube.com/watch?v=YdiZa0Y3F3c for a talk about some unique stuff that's being worked on with Julia's multi-threading (though the depth-first scheduling is not in 1.3 afaik).

They're frameworks which implement high performance tools commonly used in ml problems like tensor operations, automatic differentiation, various gradient descent optimisers, and also neural network building blocks