jondea

Can we do both? Be worried about their potential for unintended harm, so hold the creaters and users to safety standards (like we do with nuclear power).

This is not like grep or curl where it does exactly what you tell it to do.

To be fair, all of these 4 figures have warned of the danger of AI since before most people thought GPT3 level intelligence was possible.

I can believe they have economic incentives too. Although, if they do succeed in regulating themselves, won't that do more damage to their aggressive funding requirements? It will guarantee the delay (and possible banning) of the promised AGI that justifies the valuations.

Surely there are enough experts that think there's a risk that at least considering corrective action will not retrospectively look silly? (Except perhaps with hindsight bias.)

They may well be wrong, but I'm not sure you can dismiss them so easily.

And the fact it is a prisoner dilemma problem doesn't mean it's unsolvable, sure it makes it hard, but we have made _some_ progress on climate change and that's a prisoner dilemma problem.

This looks really nice! I'm interested in how the CI works though. One thing that annoys me about existing CI is that it's difficult to run locally and relatedly, config files don't work cross platform.

I'd love a CI platform that just used a super thin docker + script driver. Rather than platform specific YAML files that define steps.

The problem is that we call the things in square brackets indexes, when we should probably call them offsets

The third hole is _offset_ by 2, but if you ask a carpenter to add number labels to your pigeonholes, they are going to start at 1.

Indexes start at 1, offsets start at 0.

I think problems is too strong a word, it's just how the syntax looks. And of course it's far better than say C++. But specifically, the lack of native vectors/matrices and very few infix operators (e.g dot product, and matrix multiplication with @ is clunky). Explicit but generic broadcasting using `.` also helps.

The way that types interact with methods _feels_ like maths. I.e. you have a method made up of mathematical operators, if you swap out an input, it typically does the natural and correct thing.

I don't agree at all with your last paragraph. MATLAB and Julia are lovely for numerics, maths is terse and looks like maths! Mojo is hobbled by choosing Python style syntax, which does not lend itself well to maths.

WRT the type system, I agree MATLAB is a mess but Julia's multiple dispatch feels more like maths than any other language I've tried.

But Etsy also has these ads, and I find them even harder to identify than on Amazon

In the Dictator's Handbook the authors argued that FIFA and IOC function similar to autocratic dictatorships because there is a small group of people who are essential to power. Therefore it is rational to buy them rather than do the right thing by the fans (who have very little power). As cold as the reasoning is, the explanation stuck with me.

Their suggestion is to open up the power structure, e.g. to all past players/Olympians.

It's less compromised, but it's still basing the answer on compromised queries. This is why I pay for independent reviews (e.g Which) where their incentives are more aligned with yours.

A single energy source having a capacity factor of 10% does not imply that gas plants will have to run 90% of the time.

It ignores storage, over-provisioning, aggregation of uncorrelated sources etc.

Not to mention that wind typically has a much higher capacity factor than 10%.

I don't know what the true number is, but I think this is a low effort take.

Could you give some sources for this? I can't seem to find anything with a cursory search, but I'd be interested in reading.

The JuliaParallel/rodinia repo says that the focus of those benchmarks is the CUDA versions. I suspect that the CPU versions have not had much optimization effort spent on them. Julia isn't a magic wand, but you can usually get within a factor of 2 of C++ with similar effort.

I broadly agree that it can be hard to nail down Julia's behaviour but it does have static typing and I think it is more subtle. Function arguments and variables can be concrete types e.g. if you were implementing an approximation for sin, you could restrict arguments to Float32 if you knew it was only suitably accurate for that type.