No one has all the cards and no one controls all the levers.
I'm as fanatical a free-market fundamentalist as you'll ever meet, but if someone were to argue that government has a role in preventing bullshit like OpenAI's unilateral 40% attack on the entire DRAM market, backed by nothing but funny money, I would have a hard time coming up with defensible counterarguments.
I don’t really know much about how this stuff works, but I have a feeling we wouldn’t even have to do anything punitive. We might just need to find whatever weird loophole allows the folks who are participating in this gold rush to feel confident enough that they’ve externalized their risks to be willing to engage in speculative data center buildout projects on such a grand scale in the first place.
Usually the way the licenses are interpreted, if I run it myself and use it to generate $X million in revenue in my own business, I'm subject to the license. In this case, the license seems to cover any commercial usage at all, which would certainly include self-hosting for internal business purposes.
Why even bother demanding such terms? Release the weights or don't release the weights, but this is silly. No one is going to pay them to run or host a 7B static image model.
This week sucked, so nothing really got updated, but I took a cue from one of the previous emails and decided to blow off about 3,000 important things I should have been doing and read Magus (link to Amazon product page) instead.
I have my complaints about Amazon, but you know what I respect the hell out of them for: that 27-year-old web link still works.
They have. When you need more math -- and you will if you stick with this business for very long -- it'll usually be obvious, and you can pick up those skills then. It's never been easier.
This is why you shouldn't assume that my comment was a juxtaposition of LLMs in comparison with hand crafted feature ML models. The binary thinking is highly problematic IMO
What difference does it make? If the loop doesn't terminate, it doesn't terminate, which is almost always a bug, except when it's not. If it does terminate, then great, it terminates.
Merging a buggy loop with another loop creates... a buggy loop.
for (i=0;i<n;i++)
A[i]=0;
for (i=0;i<n;i++)
B[i]=0;
It can be conveniently transformed into this:
for (i=0;i<n;i++)
A[i]=B[i]=0;
They are exactly equivalent except if the first loop never terminates.
Now, the compiler could try to understand if the first loop does or doesn't terminate, and apply or not the optimization accordingly, but Turing tought us that is indeed a hard task!
Or it could decide to never apply it, for fear of those rare and usually pathological cases where the first loop doesn't terminate.
Or it could decide to apply it by default and accept that in those cases the program does something different than what the source code says. The latter is better known as UB.
The third option won, and that's why infinite loops are UB in the standard.
You might ask why it's important that the first loop terminates since in this case the extra side effect would just be a dead store - but if the first loop doesn't terminate then it's possible B is an invalid pointer and then accessing it during the first loop is UB when it shouldn't be. Making a nonterminating loop UB is the patch for this.
The standard example is a linked list instead of an array because the compiler can't prove it never has a cycle.
The complaint I have is that for the sake of benchmark wars, UB has been retconned from "The code might not behave the way you want under certain conditions on certain platforms, hopefully you know what you're doing" to "The compiler can do anything it wants, including rickrolling the user."
That is no longer undefined behavior in my book. That is defined behavior that just has an unusually-shitty definition.
It's all moot anyway given other trends in progress, but... UB, bah humbug. Stop trying to fix problems that no one had. This is why people are clamoring to replace C/C++ with Rust and AI and whatever. The language needed to become more understandable and more predictable in everyday use, and instead it got worse.
So you're saying the person you are responding completely failed to make their point clear?
Why use a for loop with a bound as an example instead of while loops with linked lists? He or she can prompt an LLM for a better example so laziness doesn't count as an excuse.
> Why use a for loop with a bound as an example instead of while loops with linked lists?
I'm the author of the example. I wanted to keep it as simple as possible, and this is the most common form of for loop. I was sure that HN readers would be clever enough to "map" it to whatever they have in their mind that satisfy the undecidability of the condition.
But since you're nitpicking, I haven't specified the types of i and n: i is uint8_t and n is uint32_t. Does it terminate? It depends on the value of n!
> but Turing tought us that is indeed a hard task!
Analyzing whether a bounded loop terminates is impossible, got it.
>Or it could decide to apply it by default and accept that in those cases the program does something different than what the source code says. The latter is better known as UB.
But the reason why it lets the compiler fuse the loops has nothing to do with whether the loop terminates or not. The infinite loop UB is just a way of adding more UB and then invoking non infinite loop optimization.
We don't know if A[i] aliases with the pointer that stores the address of the B array and note I mean B itself not A and B overlapping. It could also alias with the loop bound. So the first loop must run until completion simply because it could accidentally overwrite a pointer or variable that is used in the second loop.
But now that we have infinite loop UB we can ignore all of that and it's not because infinite loops themselves produce optimization potential, it's because more stuff is UB now so the compiler is allowed to break aliasing rules, which is the actual thing that was preventing the optimization. The infinite loop UB is just the permission slip.
Whenever you write a succinct example or a metaphor to try to explain in a few words a complicated concept, someone will nitpick small details of your construction, thus focusing on the form and missing the spirit!
Forget if "i<n" is decidable or not: the sense is that there will always be some loops that the compiler can't determine if it's finite or not.
Forget if A and B can alias or not: the sense is having two independent actions that can be executed in the same loop or in two consecutive loops.
Let's see... what about the following example, that replaces all a's with @ and all e's with & in a zero-terminated string s?
for (char *p=s; *p; p++)
if (*p=='a')
*p='@';
for (char *p=s; *p; p++)
if (*p=='e')
*p='&';
If a compiler is allowed to assume that the first loop terminates, then it may optimize it to:
for (char *p=s; *p; p++) {
if (*p=='a')
*p='@';
if (*p=='e')
*p='&';
}
If you really believe that the two are equivalent, I hope you’re taking action right now and not just posting on HN. Otherwise that would certainly speak poorly of your character.
I don't see many maps that include them in the visuals of border so I'm not sure of the status of that and if the feds are arguing it would count and I think they would if there was an indication they were. I do remember that that was part of the discussion when the policy/rule first got a lot of attention a few years ago but it's not showing up in the visuals now. Maybe there was a clarification or restriction added either by courts or by the executive?
Because you can't exactly sneak on/off of an international airplane. It should be pretty trivial for customs to funnel travelers through a checkpoint where they can search at the time of the actual border crossing.
Likewise we now have the technology to automatically surveil the border 24/7 (maybe modulo tunnels, though I wouldn't be surprised if we could detect those too?), so a 100-mile exception only ever becomes more and more dubious. We could've built the wall and lined it with a surveillance system for less than the cost of this Iran war (never mind all the m̶o̶n̶e̶y̶ ̶p̶r̶i̶n̶t̶i̶n̶g̶ stimulus this decade), shutting up the whole border debate once and for all, and ending justifications for internal surveillance for trafficking.
> Because you can't exactly sneak on/off of an international airplane.
I'm actually pretty curious about this. You can't easily sneak on/off a commercial international airplane, but that's because they've got the gates set up in the airport to funnel you through a specific path that leads to customs. Showing up on an international charter or GA flight seems squishier. http://www.canada.eaachapter.org/FLYING%20TO%20and%20FROM%20... The process seems to be that you schedule an ETA, taxi to a CBP station and wait there until a CBP officer arrives.
On the other side of it, it looks like CANPASS would let you land in Canada even if the CBSA station is closed...
If you fly up from countries south of the US you have a tight list of airports you can clear customs at. Wilmington NC is the odd one on the eastern seaboard. Its about 520 miles north of the nearest one. For flights coming up from the Caribbean headed to New England its a lucrative place to be.
It's still quite hard to sneakily fly into the US in a GA or charter plane and land unexpectedly at an international airport which is why they seem to not count. I say that because places like the SBCC don't include 100 mile bubbles around international airports on their maps of the issue.
On the other hand all aircraft are tracked (we are surely not trying to account for the possibility of a stealth aircraft transporting illicit goods across the border and secretly landing somewhere), and they can decide what they're going to demand from international flights. They might be somewhat lax on runway security, maybe? But it's a pretty constrained problem and easy to keep it localized if they want to tighten it.
That's great, but you and your family will go hungry as a result. If not this year, next year.
Your stance isn't new, if it's any comfort. I heard (and probably said) exactly the same thing when C compilers started getting good enough to eliminate the need for most assembly coding.
Mine, too. Now I can create a lot more software, just as I did when assemblers gave way to compilers.
The idea that this is a bad thing is just bizarre. In technology, what's anomalous isn't change, but things staying the same for 50 years, the way they have in the software business. K&R circa 1972, if transported forward in time, would instantly recognize my workflow today as being essentially the same as theirs. That's what's fucked up. It's good that something genuinely new and interesting is happening at last.
So it is your opinion that in the future llms will take extremely vague specs and turn them into fully functional software that actually works the way the prompter wanted it to?
Does the prompter sit there with the llm all day answering the 1000s of questions necessary to make what he wanted, and the prompter then spent days testing it to make sure what he initially thought he wanted is actually what he wanted?
Then for every additional feature and integration the prompter will do this again?
Are we going to make a new job title for that? Should we call that job a programmer?
Tools are tools. Better tools let us do more faster, but they are still tools.
I'm as fanatical a free-market fundamentalist as you'll ever meet, but if someone were to argue that government has a role in preventing bullshit like OpenAI's unilateral 40% attack on the entire DRAM market, backed by nothing but funny money, I would have a hard time coming up with defensible counterarguments.
reply