DSMan195276

I think you're somewhat missing the point - if the code from A and B only works if joined with C, then you should squash them all into one commit so that they can't be separated. If you do that then the problem you're describing goes away since you'll only be rebasing a single commit anyway.

Whether this is valuable is up to you, but IMO I'd say it's better practice than not. People do dumb things with the history and it's harder to do dumb things if the commits are self-contained. Additionally if a feature branch includes multiple commits + merges I'd much rather they squash that into a single commit (or a couple logical commits) instead of keeping what's likely a mess of a history anyway.

In this case because Nintendo has an American branch (Nintendo of America) that imports their goods, Nintendo of America is who paid the tariffs and would get a refund. Consumers only paid indirectly via potential price increases, so no they don't get any potential money back.

I think the public funding aspect complicates this, NASA is probably not in a position where it can blow up a bunch of rockets and still get funding for the next year.

The problem is the messy in-between, plenty of people who talk to professionals or call hotlines don't know that their questions are dumb. The bot should at a minimum say "I have no information on that" or "that's not a good idea", it should definitely not start giving nonsense recommendations just to reaffirm the question.

In other words you'd be pretty surprised if a real person in this context gave an answer even remotely close to what this chat bot gave. You can't expect a general person to know when the chat bot isn't giving back good information just because they asked something outside the norm.

Well see, you actually missed the catch that by eliminating everything except income tax people like Elon wouldn't have to pay any tax, it's even better for them. He's not getting a W-2, virtually all of his income is actually capital gains or similar.

> unless there is some reasonable person standard applied here like 'everyone knows Harry Potter, and thus they should know it is obviously not CC0'

Yes there's an expectation that you put in some minimum amount of effort. The license issue here is not subtle, the Kaggle page says they just downloaded the eBooks and converted them to txt. The author is clearly familiar enough with HP to know that it's not old enough to be public domain, and the Kaggle page makes it pretty clear that they didn't get some kind of special permission.

If you want to get more specific on the legal side then copyright infringement does not require that you _knew_ you were infringing on the copyright, it's still infringement either way and you can be made to pay damages. It's entirely on you to verify the license.

I agree it was a moderation issue, but for me it's Reddit that largely replaced my SO usage starting some years ago. Reddit is pretty similar to SO in design, but the more decentralized nature of the moderation means that questions rarely get "closed as duplicate" and answers tend to be more up-to-date as a result. There's not always a consensus answer and I'm often looking across multiple threads on the same thing, but that's still better than an outdated SO post.

Something that bothers me here is that Anthropic claimed in their blog post that the Linux kernel could boot on x86 - is this not actually true then? They just made that part up?

It seemed pretty unambiguous to me from the blog post that they were saying the kernel could boot on all three arch's, but clearly that's not true unless they did some serious hand-waving with kernel config options. Looking closer in the repo they only show a claimed Linux boot for RISC-V, so...

[0]: https://www.anthropic.com/engineering/building-c-compiler - "build a bootable Linux 6.9 on x86, ARM, and RISC-V."

[1]: https://github.com/anthropics/claudes-c-compiler/blob/main/B... - only shows a test of RISC-V

It's phishy because it's breaks the rules people are generally told for avoiding phishing links, mainly that they should pay attention to the domain rather than subdomains. Browser even highlight that part specifically so that you pay attention to it, because you can't fake the real domain. The problem with what GitHub does here is that while `github.github.io` might be the real GitHub, `foobar-github.github.io` is not because anybody can get a github.io via their username, that was part of why they made github.io separate. Additionally they could easily host this via GitHub Pages but still use a custom domain back to github.com, they just don't.

I would say that GitHub is particularly bad about this as they also use `github.blog` for announcements. I'm not sure if they have any others, but then that's the problem, you can't expect people to magically know which of your different domains are and aren't real if you use more than one. They even announced the github.com SSH key change on github.blog.

Without questioning the LOC metric itself, I'll propose a different problem: LOC for human and AI projects are not necessarily comparable for judging their complexity.

For a human, writing 100k LOC to do something that might only really need 15k would be a bit surprising and unexpected - a human would probably reconsider what they were doing well before they typed 100k LOC. Where-as, an AI doesn't necessarily have that concern - it can just keep generating code and doesn't care how long it will take so it doesn't have the same practical pressure to produce concise code.

The result is that while for large enough human-written programs there's probably an average "density" they reach in relation of LOC vs. complexity of the original problem, AI-generated programs probably average out at an entirely different "density" number.

Yeah I agree that one isn't very clear, perhaps the idea is to use `msync()` as a barrier to achieve consistent ordering of the writes without having to handle that yourself with more complex primitives. But then, they do mention some of those primitives at the bottom of the article, so it's hard to say what exactly the idea is.

Just because you believe X is going to happen doesn't mean you can make money in the market off of that information, that requires judging what _everyone else_ thinks will happen and thus how the market is priced. You could just as easily get stuck in the situation where the market as a whole was expecting it to be worse than it was and didn't move far enough for you to make your money back.

I would add, I've always felt the addition of the 3D screen also held it back because the touch screen became relegated to always being secondary (so that the main display of the game could be 3D). Many games that were sequels to touch-focused DS games did this, they had you touching the bottom screen to interact with something on the top screen and made those games feel a lot worse to me.

Pawns only get 6 moves :) But also they can't all make 6 moves because they can only move past each-other via capture, so half of them would get 5 moves instead (if you're counting all the captures), so that gives a maximum of ~8850.

It depends what rules you're using, but there are the three-fold repetition and 50-move rules which allow a player to force the game to end in a draw. The catch is they both require one of the players to claim a draw under the rule, otherwise they can keep playing.

There is additionally the 75-move rule where the the game is forced to be over without either player claiming the rule (the arbiter just ends the game), that rule would give an upper bound regardless of the players knowledge of the rules.

Comparing Chess AI to AlphaStar seems pretty messy, StarCraft is such a different type of game. With Chess it doesn't matter if you get an AI like Lc0 to follow lines it played previously because just knowing what it's going to play next doesn't really help you much at all, the hard part is still finding a win that it didn't find itself.

In comparison with StarCraft there's a rock-paper-scissors aspect with the units that makes it an inherent advantage to know what your opponent is doing or going to do. The same thing happens with human players, they hide their accounts to prevent others from discovering their prepared strategies.

> Presumably, there's a step in this process where money incentivizes the opposite of my suggestion, and I'm not familiar with the process to know which.

> Is it the university itself which will be starved of resources if it's not pumping out novel (yet unreproducible) research?

Researchers apply for grants to fund their research, the university is generally not paying for it and instead they receive a cut of the grant money if it is awarded (IE. The grant covers the costs to the university for providing the facilities to do the research). If a researcher could get funding to reproduce a result then they could absolutely do it, but that's not what funds are usually being handed out for.

> Do you debug JVM bytecode? V8's internals? No.

I can't speak for the author, but I do often do this. IMO it's a misleading comparison though, you don't have to debug those things because rarely does the compiler output incorrect code compared to the code you provided, it's not so simple for an LLM.

`eay` is just the initials of the original author, so basically the same thing as `awk`.

You can, but then the names get needlessly long and one of the things we generally like (especially for command-line programs) is names that are short and easy to type. If we're going to make this argument then why not call the unix tools `concatenate`, `difference`, `stream-editor`, etc. Those are way better names in terms of telling you what they do, but from a usability standpoint they stink to type out.

Libraries and programs also have a habit of gradually changing what exactly they're about and used for. Changing their name at that point doesn't usually make sense, so you'll still end up with long names that don't actually match exactly what it does. Imagine if we were typing out `tape-archive` to make tarballs, it's a historically accurate name but gives you no hint about how people actually use it today. The name remains only because `tar` is pretty generic and there's too much inertia to change it. Honestly I'd say `cat` is the same, It's pretty rare that I see someone actually use it to concatenate multiple files rather than dump a single file to stdout.

The author is missing the fact that stuff like `libsodium` is no differently named from all the other stuff he mentioned. If he used libsodium often then he may just as well have mentioned it as well-named due to it's relation to salt and would instead be complaining about some other library name that he doesn't know much about or doesn't use often. I _understand_ why he's annoyed, but my point is that it's simply nothing new and he's just noticing it now.

Yeah this definitely falls into the category of "I use them so they feel natural", there's nothing amazing about those names.

The underlying problem is that you now run into so many named things (utilities, libraries, programs, etc.) in a day and they all have to differentiate themselves somehow. You can't name every crypto library `libcrypto` for obvious reasons.

I think the problem is that if they're in the road their liability and required smarts go up a lot. Right now it sounds like they're at least partially relying on being the largest thing on the "road" and everyone else will naturally get out of their way.

In this case the problem is that the fed is the one who runs the TSA and created the Real ID rules, but the states are the ones that actually issue the IDs meeting those rules. The fed couldn't force the states to implement the rules and the states didn't want to spend money on something they didn't really care about.

Of course, they didn't really care about it because it's mostly just security theater and thus the fed was never going to start turning people away simply for not having a compliant ID (which is still true). If there were much more valid reasons for why everybody needs to have a Real ID then states would have put more effort into getting everybody to have one.

There's also the separate the issue that the Real ID rules are questionable and it's not always easy for someone to get a Real ID even if they want one.

It's a single number in that if you take an IQ test one time you get one number, but that doesn't mean you'll get that exact number every single time you take an IQ test. Even ignoring more complex questions about them, your score on an IQ test will vary depending on simple things like how tired you are when you take it, so in practice there's some variance and you do not always get the same number every time you take a test.

Well based on the paragraphs in the README it's not actually being updated anymore, it only reflects SteamOS as of August and the author quit running their process to update it.

What prevents a farmer from simply switching back to the non-GMO seeds if the GMO option goes up in price? Or even ignoring that, switching to a different cheaper GMO seed from a different company?

I think that's the piece I and others are missing, isn't it ultimately a question of which seeds will make the farmer the most money? If a particular GMO seed suddenly become so expensive that either non-GMO or other GMO seeds are more cost-effective, why can't they just start using them instead?

"Bugfixes" doesn't mean the code actually got better, it just means someone attempted to fix a bug. I've seen plenty of people make code worse and more buggy by trying to fix a bug, and also plenty of old "maintained" code that still has tons of bugs because it started from the wrong foundation and everyone kept bolting on fixes around the bad part.

It's a difference of whether the function arguments are declared or not. If you declare a `void foo()`, and then call `foo((float)f)`, the `foo()` function is actually passed a `double` as the first argument rather than a `float`. If you instead change the declaration to `void foo(float)` then it gets passed as a `float`.

Ex: https://godbolt.org/z/TKjz3Tqqr

> I'd go read the original PR and the discussion that took place.

Until your company switches code repos multiple times and all the PR history is gone or hard/impossible to track down.

I will say, I don't usually make people clean up their commits and also usually recommend squashing PRs for any teams that aren't comfortable with `git`. When people do take the time to make a sensible commit history (when a PR warrants more than one commit) it makes looking back through their code history to understand what was going on 1000% easier. It also forces people to actually look over all of their changes, which is something I find a lot of people don't bother to do and their code quality suffers a lot as a result.

FWIW licensing is definitely part of why some 'obvious' stuff is still missing, Nintendo doesn't own the rights to games that they didn't develop themselves (generally speaking).

Ex. We'll probably never see the first six FF games on Switch Online, Square Enix is just unlikely to agree to that for a variety of reasons.