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.

Do any of the Scottish National Party, Plaid Cymru or Sinn Féin count? I have no doubt there are similar elsewhere...

I'm surprised it isn't mentioned in the article, but you can get rid of yellow stains by putting your clothes out in the sun.

If it helps, the meta analysis is called: Volatile organic compounds analysis as promising biomarkers for Parkinson’s disease diagnosis: A systematic review and meta

Absolutely, it may not be useful as a screening test on the general population, but it may be useful as a piece of evidence for diagnosis alongside other pieces of evidence. Even for a test with a lot of false positives, the P(Parkinson's|positive) > P(Parkinson's|negative).

I generally agree that a lot of media doesn't accurately portray uncertainty in medical advancements, buts it's not as simple as having a sample size threshold. It really depends on the significance and the strength of the effect. Also, I want to hear about the exciting preliminary stuff, provided that it's properly caveated. There's just a lot of incentives to sensationalise.

I'm not an expert, but a very quick search showed a meta analysis[1] which considers the false positives of using volatile biomarkers as a diagnosis. The original paper[2], of which Joy is co-author has a much smaller sample size, but also has a control group to measure false positives.

Again, I'm not an expert, but from personal experience I know that Parkinson's can be hard to diagnose definitively until there are serious symptoms. This test may be relatively poor but still be useful as a piece of evidence.

[1]: https://www.sciencedirect.com/science/article/abs/pii/S03038...

[2]: https://pubs.acs.org/doi/full/10.1021/acscentsci.8b00879

Computing convolutions using FFTs is efficient for large kernels (or filters). Most convolutions in popular ML models have small kernels, a regime where it is typically more efficient to reformulate the convolution as a matrix multiplication.

I think your complexity argument is correct for N=pixels=kernel size. But typically, pixels>>kernel size.

Disclosure: I work at Arm optimising open source ML frameworks. Opinions are my own.