> This week I replaced my home security camera system with open source Frigate, because I was able to use AI to take the source code, replace the object detection models that were included with the code with something that was a better fit for my machine, customize how the videos were stored and under what circumstances. There's a lot more that I can do with it that I haven't yet as well.
>
> I couldn't do that with the proprietary system.
You also didn't give anything to opensource. This shows that AI can allow open source to be used in more cases and in more flexible ways, but in no way does this mean that open source (and especially the good high quality one) will explode.
If anything we saw an explosion of open source projects, most of them low quality slop, and even the ones that used to be high quality are slowly degrading.
The prevailing moral panic prevents anyone in the space from sharing in communities where open source is generally discussed. People flag and openly disparage (against community guidelines) and have histrionic reactions.
We'll just have to wait until the topic cools off before we can see how llm usage impacts open source.
That's valid. I didn't contribute anything back yet but I certainly could at the point that I'm convinced the refinements are polished enough.
At the same time, how different is that from much of open source today. Usage is dramatically higher than contributions. How many open source packages are included in every software project we build with. How many of those are any of us contributing back to?
The open source "gift economy" is a patronage system akin to the Renaissance arts, enabled by maximal extractive leverage. AI represents a democratization of the human machine interface
> Another way is to think of it as an interval of real numbers between the next lowest and highest intervals. Under this latter interpretation, it makes sense to discuss shortest decimal string within the interval, 0.3 in this case.
Note that the result of 0.1+0.2 does not lie in the interval containing 0.3, which is was confuses most people. The issue is that there is some imprecision in representing 0.1 and 0.2 too, and that compounds when summing, resulting in something that does not actually correspond to 0.3 (hence the classic 0.1+0.2!=0.3)
But, as I understand it, 1+2=3 in all of these senses using floating point; as long as you don’t go outside of a certain very large range, they are really a superset of integers.
That makes me think that I can just plan ahead by storing the number of cents instead of dollars, or a “hack”, and then it makes me wonder why the format even requires me to do that.
> That makes me think that I can just plan ahead by storing the number of cents instead of dollars
That's what is generally suggested when handling money, at least for normal businesses (in finance related businesses you might have to handle a lot more decimal places for things like exchange rates, fractions of cryptos etc etc)
Be careful though that some currencies require more than 2 decimal places.
0.2+0.1 with floating point numbers _is_ deterministic, as you'll always get the same answer.
I suspect you might instead mean exact calculations/answers (in the example above, neither 0.1, 0.2 nor 0.3 have exact representations using floating point numbers).
And just to be clear, there are non-determinism-like issues with floating point numbers, but those are much rarer/niche and _can_ be fixed. For example parallel summation depends on the order the summation was made, so non-determinism in the parallel implementation ripples through the summation result. Some non-basic operations (e.g. trigonometric operations) have platform dependent implementations with different roundings, so you might experience different result based on the platform you're on.
And they are probably right. But they are probably also missing that this will translate to worse quality. You know, the classic "you can only pick two among good, cheap and fast"
I've had Apple approve app submissions within 24 hours. It certainly hasn't been the norm (on average for me it takes more than 1 day, but less than 2), but I've had it happen occasionally over the past couple of years.
Not only that, if you have `trait Foo: Iterator<Item = u8>` and `trait Bar: Iterator<Item = i32>` how could `!` implement both of them? It would simply make the language incoherent.
reply