simonbyrne

Agree 100%. Free CI really did provide a massive boost to collaborative open source projects.

As a user, it did a lot to increase software quality: not just catching inadvertent bugs, but also ensuring that there was at least some reproducible way to get the code working, that didn't depend on some implicit configuration of the authors system.

As a maintainer, accepting simple pull requests becomes much easier when you can quickly look over the code and check the CI status, and not have to try it out locally yourself. It was certainly critical to the "social coding" idea behind GitHub.

So thanks to the team that put it together. Even if the product you built doesn't live on in the way you hoped, it has certainly had a lasting impact for the better on the open source world.

It's also a matter of integration (common ticketing, timetabling of connections, sharing stations): the Bay Area is atrocious for this. LA is slightly better, but still leaves a lot to be desired.

It's not just that governments are dependant on the money, it's also that the gambling can then fund vast lobbying arms to the detriment of good policy.

This has certainly happened in Australia (especially NSW): two of the biggest political donors are the Australian Hotels Association (AHA) and ClubsNSW, which represent the principal beneficiaries from video gambling machines: https://www.smh.com.au/national/nsw/machine-men-how-the-aha-...

I know it's an empirical result, but it would be interesting if it was truly logarithmic. Classic statistics gives various asymptotic results based on variations of the central limit theorem, which generally imply sqrt(n) scaling, but these assume various regularity conditions (typically smoothness and fixed dimensionality).

It would be interesting if there was some corresponding law for more flexible models which did indeed give you logarithmic scaling.

The Queen has immense theoretical powers, but it would trigger a major constitutional crisis if she were to exercise any of them without being asked by the PM.

He has never been an MP.

I agree that extended precision can be very useful, though I think the failing was on the software side: basically languages and compilers didn't provide useful constructs to control things like register spilling (which caused the truncation of the extended precision).

The current hardware trends seem to be providing instructions for compensated arithmetic, like FMA and "2sum" operations. I think this is ultimately a better solution, and will make it possible to give finer control of accuracy (though there will still be challenges on the software/language side of how to make use of them).

Essentially there are two different sets of floating point instructions on x86 and x86-64: - the x87 instructions, which descend from the original 8087 coprocessor (and have 80-bit registers), and - the SSE instructions, which descend from the Pentium MMX feature set, are faster, support SIMD operations, and can be fully pipelined.

The x87 instructions are basically for legacy compatibility, or if you manually use long doubles on some platforms.

The idea behind extended precision registers was good in theory, but ultimately caused too much hassle in practice.

What is kind of funny was that it varied by markets: Yahoo Messenger was big in commodities markets, especially oil.

In general, no, but it's complicated (https://www.lexology.com/library/detail.aspx?g=60a2afec-34c8...).

Interesting side note: his friend Persi Diaconis (mentioned in the article) is the author of many interesting probability papers, including the proof that "7 riffle shuffles is enough" (https://statweb.stanford.edu/~cgates/PERSI/papers/aldous86.p...)

Any studies you can link to?

They're 32-bit IEEE floats (i.e. a typical "C float"), so the subnormal range is below 2e-38. Also, it isn't printing exact values, since for any non-integer value, the last digit should always be 5, though I agree it would be nice to have.

There is precedent for this solution: https://academic.oup.com/biomet/article-abstract/76/1/183/22...

This is really cool, and I'm excited to see how this goes. When people first hear about automatic differentiation, their first reaction is "that's cool, why isn't it everywhere?", and the answer has been "it's really hard to use in practice".

Until recently, AD systems only worked on restricted subsets of languages, or required extremely cumbersome template usage throughout the code. ML frameworks like TensorFlow pushed AD into the mainstream: they are essentially AD-compatible runtimes, but they are cumbersome to use (you have to use their functions instead of the language-provided ones) and they miss potential optimisations.

So it's become increasingly clear that the next step was to actually embed AD as part of a language. I work on Julia, so I hope Zygote.jl (https://github.com/FluxML/Zygote.jl) gets there first, but it's always good to see others moving in the same direction.

> Taxes are utilized notoriously inefficiently in the US.

I've wondered about this: is this "conventional wisdom", or are there actual cross-country comparison studies?

There is also a lack of what is considered "Excel best practices", for want of a better word. The only resource I've seen along those lines is Joel Spolsky's "You Suck at Excel" video (which is excellent, and should be necessary viewing for anyone who use Excel on a regular basis): https://www.youtube.com/watch?v=0nbkaYsR94c

> Does the US government also manage food and water in China?

No, but the US certainly does regulate how companies can act in other countries, e.g. the FCPA.

> If Google gets screwed for doing business in China while thousands of other companies get away with it, what kind of incentive does that show?

It shows that the government believes some principles should be above making a quick buck.

It still takes ~30 mins, and the one near me isn't open on Sunday afternoons, which cuts into my Monday morning and pushes a 2 day rental to a 3 day one.

I don't understand why car rental places haven't tried to address this yet: e.g. offer drop-off and pick-up (of the car, not me), including evening and weekends.

You can sort of get this through Turo, but you don't get the network benefits (one-way rentals, easy replacement, etc.).

A common work around is to make them all the same: that way you don't have to think which ones to type.

Agreed. The costs vary a lot too: the US is pretty good ($100/5 years, includes precheck), but you would have to travel a fair bit to make it worthwhile in the UK (£50/1 year + £20 registration).

My suggestion: any politician who states "[country name] is open for business" should be required to enter through the foreigners line.

Though £1k/month is at the extreme end, UK train tickets can get expensive: https://www.telegraph.co.uk/news/2017/08/15/dawn-10k-commute...

> They did a lot of mathematical analysis to decide that 80 bits for the internal number format would result in accurate 64 bit results. Something about losing lots of bits of accuracy during exponentiation, so you want extra bits the size of the exponent.

I'm not sure if it was the reason, but 80-bit intermediate values lets you compute pow(x,y) as exp(y*log(x)) to full precision for the full range of 64-bit floats.

I recall seeing a comment by Will Kahan that 80-bit bit was intended as an intermediate step: the intention was to eventually go to 128-bit.

Also this was still early days: up until this point, fast floating point was the domain of much more expensive machines. No one had any idea what would be useful in consumer level hardware.

I'd be keen to know more about how the transcendental instructions worked.

I believe most electric buses do: adding regenerative braking to electric vehicles requires little additional hardware (the electric motors can act as generators, etc.), so it is certainly cost-effective.

Apologies, I realise my comment was a bit snarky. Pony looks like a really neat language: I'll be interested to see what you do with it.

Unfortunately LLVM considers division overflow undefined: http://llvm.org/docs/LangRef.html#id109

If it's any use, you can see what Julia ended up doing here: https://github.com/JuliaLang/julia/issues/8188

What about I64.min_value() / (-1)? Why does that give 0? If you're doing wrap-around arithmetic it should give I64.min_value().

https://tio.run/##K8jPq/z/PzG5JL9IwTcxM49LAQjyUssVkotSE0tSNV...