Funny how this is country specific. Some of these would still be very unusual to have changed in the U.K… Ashley in particular, I’ve seen it as a girl’s name but only rarely here.

It used to be more common in the U.K. but it’s pretty rare now. Stews and braising were the traditional way to cook it as older ones are kind of tough.

I think they do but only when it's applied to learn some specific spatial task.

We can see for e.g. that frontier models have got really good at CAD sorts of tasks recently. That suggests benchmaxxing RL to a degree but it does mean they've suddenly got quite good at forming simple geometries in a step by step way.

This misses the point entirely of why C is as it is.

It’s quirky because when you had kilobytes of RAM, storing the length of the string was memory you couldn’t afford. Arrays decaying into pointers similarly meant carrying a single pointer around rather than a fat struct. Magic integers for return codes were used because they’d fit into a single register. Compilers didn’t have the processing power or memory to track complex borrow rules or static analysis. They were slow even as they were! Old processor architectures were way more diverse and fragmented than now - and even 30 years ago endianness wasn’t a settled thing.

Things weren’t quirky because people “wanted” them to be, they were quirky because everything was way more constrained. Rust came into a way more rationalised environment and it’s a great language of course but the operating environment is so totally different it’s hard to compare.

Colin Furze - and at least for part of it he didn’t! The council sent him an enforcement notice and he had to get it done retrospectively

His underground garage however has planning permission- you can find it on the council’s planning portal

tbf all of it now has planning permission it was just retrospective, the docs are still published the same way

> I did a PhD in magnetic materials

There are two of us on here!

I was going to say that people encounter ferrimagnets more commonly than pure ferromagnets I think, since as we both know pure ferromagnets tend not to have very high anisotropy.

All I learned in school was bar magnets covered with iron filings - furrymagnets.

Very good!

I got Claude to design me a shed the other day. I asked it to make the door hinged in the CAD software I am using, and it did, but parts of the door weren't attached to each other so some were left floating when I set the door open.

People were definitely asking for it.

It's been discussed for a long time, and the related proposals were heavily upvoted, including various older proposals.

As I understand it, part of the reason it took a while is that the core Go team was generally of the opinion that doing user-facing SIMD APIs the right way was to design a high-level, cross-platform API that would stand the test of time, and that was then punted a few times given its complexity and need to do other things.

Part of what helped the current approach take off was switching to a philosophy of designing a lower-level architecture-dependent API first (the 'simd/archsimd' package), and then later doing a higher-level portable API (the 'simd' package, which is topic of this blog post).

That two-level approach I think also gave some additional freedom for the design and implementation of the friendlier / high-level 'simd' package, including because the lower-level 'simd/archsimd' package is available for people who need or want to drop down.

It's a nice design.

Layered API design is a great way to resolve ergonomics/performance tradeoffs.

Oh this is great, it was one of my biggest bugbears about Go since you almost always have to link C/C++ code to get the appropriate performance.

The one negative I'd say is that often autovectorisation is 'good enough' and this doesn't really tackle that gap.

FWIW, there is some pretty substantial autovectorization work that is already in-flight for the Go compiler.

There's a CL stack here:

https://go.dev/cl/791740

It's hard to make predictions with an open source project, but my personal guess is some flavor of it will land (including it is already demonstrating good results without an enormous level of code complexity in the compiler and without overly slowing down compile speeds), but I guess we'll see.

It's being driven by an external contributor who has landed some good changes in the past to the Go compiler. (I think the autovectorization work might be part of their PhD or other academic research, but not sure.)

As a first step, it might be possible to write a linter rule that rewrites suitable numeric loops to SIMD. There are already rules to rewrite several loop types, so that should be doable.

The poor Assembler and the unsafe package forgotten in the corner.

While reaching out to CGO is the easier way, it doesn't mean it is the only tool available in Go.

> I live in a European country, where the phone company hasn't bothered to come remove the old unused copper phone lines in the last 5 years. Thousands of dollars worth of cables running past my house alone, and no one has bothered to go strip it in the night and sell it

Isn't that because they're still flat out on rolling fibre out? There's not that many telecoms engineers and if they spend tons of time removing the old, that slows down the new.

> Isn't that because they're still flat out on rolling fibre out?

Spain's rollout is up in the last few percentage points (>95%) of fibre coverage, in this particular region we reached saturation of the entire rural area 5 years ago.

Plenty of time for those disconnected copper cables to go walkabout if anyone were so inclined. Realistically, in a region where the population skews older and most everyone owns property, it's probably not worth the risk to fence it

We're still quite some way off that in the UK. Copper lines still working though due to shut down by next year I think. Lots of older people with no internet left in the lurch with phone lines with that of course.