skysight-inc/HackerNews huggingface dataset:
Submit illegitimates ones instead? At least, there are days when it seems like that’s how it apparently works.
This reminds me of this reddit question https://www.reddit.com/r/askmath/comments/1eakt5c/if_you_pic...
"If you pick a real number from 0 to 1, what is the probability that it is rational?"

and the first response,
"
With a uniform random process over an interval (a, b), you can find the probability of picking an element from a set X by integrating 1/(b - a) over the set X.

Since the (lebesgue) integral of the rational numbers is 0, the probability of picking a rational number is 0.
"
And that kinda broke my brain for an afternoon.

So, when a computer represents a number, it's always rational. You can have a lot of memory, but always finite.

Now, you can go further, and represent things symbolically, like sage math or a bunch of other systems. But (I believe) at the end of the day Godel always wins. There are always true statements that can't be proved. If I remember right, computable stuff is a subset (maybe improper?) of provable stuff.

Looks interesting. Thank you for posting it. I'll try to read it later. Although, I'm a math tourist. I probably won't be able to give you any grand insight.
yeah, git is just the right layer of indirection to support everyone's weird take on how the workflow should go, so you can just use it however you want.
Equality of real numbers is undecidable. Specifically recursively undecidable, which is the same as uncomputable.

The Real numbers are topologically weird when you dig into it.

Random example.

https://mathworld.wolfram.com/RichardsonsTheorem.html
My first job out of college was on a university administrative system where all the source files were managed by RCS. I came on in '97, but the system had been operation in at least that state to 1995. Obnoxiously, the vendor layered some secret sauce on top of it in Makefiles for the actual checkins and outs, so you did something like `make co F=foo.c` which totally messed up filename completion. I had it aliased in tcsh within minutes to preserve my own sanity.

When my consultant contract finally came to an end in 2003 they were still using it.
When I have used them for backups, the 40gb buffer quickly fills and then I'm stuck with speeds slower than my internet connection until the buffer empties, which it will only do if I kill the existing transfer. SSDs can dump 40gb of data very quickly. Annoyingly, since the r/w head has to do it's back-and-forth dance between the buffer area and the SMR areas, this condition even impacts read speeds. Consequently I wouldn't even use them for backups. Nor would I buy them again. I've set them up as Storj drives, which they seem to handle reasonably, and I am thankful to be done with them otherwise.

If you're considering one, I would pay special attention to the buffer size, and ensure that all the transfers you want to do to or from the drive are significantly smaller than the buffer to ensure reasonable performance. That excludes most video too. Storj files are typically just a few megabytes, and typically arrive at a frequency of just one or two per second, which the drive can handle.
But is the logical conclusion.

Rescue is that, being rescued.
It's good to know I'm not the only one! I think I started using asdf on Descent then loved it for Quake too. I still use it too.
I've thought for a long time that medicine in the AI era would end up with nurses being even more important than they are today but with doctors being drastically less so. (I know next to nothing about healthcare; this is just a guess!)
I've updated my comment with appropriate pedantedits.
What an interesting discussion. Especially everything about that writing it in Asm would be the solution if you want secure code.

Both, gcc and clang, are orders of magnitude better tested than all the closed source applications, developed under tight timelines and that we essentially trust our lives with.

To be very clear, there are compiler bugs but those are almost never the problem in the first place. In the vast majority of cases it starts with buggy user code. An now back to handwritten assembly…
You are so right. There is a reason why PC and arcade monitors work in RGB.

But in addition to that, there is no cross-talk, no dot crawl, and all the other weird artifacts of composite video. Also, no chroma modulation means that it was much easier for TVs to support both 50 and 60 Hz. I only ever had a GameCube, but being able to play in RGB at 60 Hz was amazing.

At least in Europe, many old consoles* provided native RGBS output, and with the proper SCART cable the video quality was awesome. Nowadays, people in the retro gaming community go crazy with PVM/BVM and other fancy professional monitors with RGB input, but the French already had it figured out in the '70s!

* anything from Sega, Nintendo SNES~WiiU, the NeoGeo, Sony PSX~PS3.
That was the default for a bunch of 8bit systems, for me, the Spectrum series
How I Use "AI"
> However, we find no evidence of reshoring or friend-shoring

Between how specialized a lot of the tech is and a lot of things only being worth doing if it is cheap, was this surprising?
I don't know why this popped up on HN after four years, but author here to answer your questions...
2 things.

1. That is an amazing design and amazing engineering. I legitimately am astounded by the creativity and thought that went into that.

2. The writing style where the author feels the need to apologize for anything even remotely technical (like: Once again, just bear with us for a bit) comes across as either childish or condescending. What purpose does that serve? Anyone clicking a link about an old arcade game with no computer or screen obviously wants to know how it works. Why write like that?
How many of the "polling issues" can be explained by clients doing heuristic caching[1][2] due to a lack of a `Cache-Control` header in the responses?

If the feed was last updated (for example) 1 hour ago, and the response lacks a `Cache-Control` header, in that case the response would be cached for 6 minutes (10% of 1 hour; the 10% is mentioned in RFC 9111 section 4.2.2).

[1]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#he...

[2]: https://datatracker.ietf.org/doc/html/rfc9111#name-calculati...
GitHub won because they built a great product. It was better than all the alternatives and people flocked to it for that reason.

Git itself is mediocre, and some other DVCS like Mercurial could have won out, although HgHub really doesn't have the same ring to it. The halo effect from the Linux kernel was also a factor. But the VC cash dump and Microsoft buyout came later, people used GitHub because it was better than the rest.
When it's even available. But then they start cranking the ratchet, increasing the no-ad price and introducing a with-ads tier at the old no-ad price, or cutting quality, or cutting corners on customer service and security, etc etc. We've seen this play out many many times and it's a fundamental outcome in even the most basic econ 101 models: an oligopoly with high switching costs is more profitable for suppliers than a free market, made all the moreso by tacit collusion. An unregulated free market is essentially doomed to fail whenever an opportunity to establish such an oligopoly arises.

In extreme cases it does start to look like a protection racket, especially when important services like broadband Internet are involved.
Yeah, relying too much on modified headers from requests to send the appropriate response isn't ideal, because request headers can be incorrect and largely unreliable.

Responding with a Cache-Control header with a max-age seems like a much more superior option for these cases.
As awesome as these algorithms are, I can never imagine use case.

Any time I need to turn something into uppercase or lowercase, it's user's input or something Unicode. Which can be in any random language, so all the crazy Unicode casing rules apply.

I mean, Czech could work by canonical Unicode decomposition and then re-composition afer case change ...but the input can be in Russian or Greek. I can't imagine accelerating that, or rather taking into account all the ranges.
Good thing I’m a hoarder. If I like something, I archive it and back it up locally. For example, a couple of days ago, I needed some digital assets for an Adobe program that I had downloaded a few months ago because I liked them and thought I might need them in the future. When I went back to the company page a couple days ago, everything had vanished! I'm glad I had downloaded them before and checked my backup to retrieve them.
>so it doesn't really matter if it is optimized away.

There are cases in which the optimization can result in behavior other than segfaulting, see https://research.swtch.com/ub#null
A Case for Planned Durability in Tech (2022)
Well, it’s not a paradox if you assume you’re special. What else would you expect from the species that named itself “sapiens?”
>computer scientists at Atari studied user interface stuff with game performance in mind

2600 and 5200 controllers say otherwise.
This made me think of my first job. I was the sole developer on a project because the old developer left. Nothing was documented and nobody knew why things were designed the way they were.

We had no code reviews, no design docs, no tests, nothing. We made the changes the way we thought they were right and would git pull them onto the production server.

After I struggled to get productive for the first four months, my manager went on a four-week Christmas vacation. In a moment of frustration, I seized the opportunity and rewrote the whole project from scratch. I don’t remember if my manager ever noticed, but that was the moment I finally got productive.
They are underinsured but it’s because we are building homes in places they don’t belong, that historically have been wiped out by natural disaster such as wildfire. Climate crisis or not, you don’t have to do a lot of digging to read the stories of entire Gold-rush era towns being wiped off the map by fires.
> Nope. You're thinking about this mathematically, not algorithmically.

I don't know what you mean by this, and I'm not sure how it relates to what I said. I'm using "decidable" in the strict, computer-science sense of the word.

The statement in example 1 of the paper, which we're discussing, is about computable real numbers. A computable real number is one for which there is a Turing machine that can calculate it to any desired finite precision in finite time.

A semidecidable problem is one for which there is a program that halts if the answer is "yes", but may not halt if the answer is "no". The halting problem is in this category.

Given a computable real number x, asking whether x<0 or x>0 are semidecidable but not decidable problems.
For the One Definition Rule specifically, sure, the tools could just be better, it would be extremely difficult in C++ but this entire problem doesn't arise in many languages.

However a bunch of IFNDR in C++ covers cases where Rice's Theorem applies, so your static analysis cannot help.

Rice says that if you language has non-trivial semantic requirements (not just syntactic ones) that's Undecidable, which means there cannot be any algorithm which always says whether any program does or does not satify the requirement.

C++ is reluctant to lose any programs which might potentially satisfy its requirements, so instead it chooses to say that they must compile unless the compiler can prove they do not, which by Rice we know cannot be 100% effective. In practice, why even bother? Many compilers don't put much work into trying, it might help users but it's not a compliance requirement so it's often not a priority.

Rust's choice here (thus avoiding IFNDR) is to reject programs unless it can show that they meet the requirements. Even if you can convince a PhD team that your program satisfies the requirements, that won't help, rustc needs to be convinced or it won't compile. Unlike C++ the incentives here are aligned, that's what Rust's "Non-lexical lifetimes" change was about - the compiler got smarter, allowing previously unacceptable Rust to compile.
GTA 3 is being ported to the Sega Dreamcast
The printer took a big roll of paper, maybe 5 inches in diameter (although I don't have it here to check). I was a bit surprised that they didn't trim the roll down to the minimum size necessary, but just used a full roll. I guess they didn't want to waste paper :-) Also, I'm surprised that they used cheap-looking yellow paper rather than white paper, but maybe there's a reason teletypes used yellow paper. (The paper hasn't yellowed due to age; it's yellow in contemporary photos.)
Indeed, this seems to be the insight around vertical slice architecture? https://www.jimmybogard.com/vertical-slice-architecture/
I agree that given two computable real numbers x,y, asking whether x=y is undecidable.

The point I'm making is that it can't be true that x<y or x>y are decidable, because then x=y would also be decidable, and it isn't.
I'd like to dump the ROMs, but they are soldered in and covered with conformal coating, so it would be moderately destructive to remove them and dump the contents.
> how is it possible that there can be a continuous computable function whose derivative is uncomputable?

For others: The original paper is short and very readable - https://projecteuclid.org/journalArticle/Download?urlId=10.1...

The intuition seems to be that computability of a function is actually approximability, and derivatives can be large even when the function is very small, by having the large slope confined to a very small area. So by constructing a function f that contains an uncomputable (but recursively enumerable!) set encoded in the derivative by strategically placing little bumps, but having the bumps grow exponentially smaller, Myhill was able to construct a function that was easily approximable but whose derivative wasn't.

The key detail here is that the bumps grow exponentially smaller in the order the uncomputable set appears in its enumeration. This allows Myhill to construct a sequence of computable functions that (uniformly) approximate f to within 2^(-n). If the bumps weren't ordered in this way, we wouldn't know how far down the sequence to go to approximate f to within 2^(-n). The ordering lets us just look at the first n elements of the uncomputable set.

Why doesn't this allow us to approximate the derivative? Because at any x, we don't know how well we have to approximate f in order to approximate f'(x), so we need knowledge of the entire uncomputable set, which we cannot have.
Don't use LIMIT OFFSET for pagination in PostgreSQL
And lo, on the first day god created the test
Imagine someone having an opinion other than yours...
Your original response of "it has few citations so it's unremarkable" was also an NPC response, which I wouldn't have commented on except that you're calling other people's responses NPC responses.
Until about 2014 or so in my department, when we started using SVN. We were more concerned about file locking and a "single version of the truth" of MS Word files stored centrally but accessed locally than we were of fine-grained version control, and Git didn't have the kind of file locking we needed (as I understood it).
I cranked out a Lua interpreter implemented in Rust in a week or two.

It only ran about 3x slower than PUC Lua... And never collected garbage either :P
There’s an addon called single file, you can use it to save the whole page with assets (except videos)

https://github.com/gildas-lormeau/SingleFile
I have to work with a DBA who has decided that nothing new gets developed using Postgres and is confident that our use cases are best served with a document db… all without knowing any of our use cases, requirements or constraints.

Now I just don’t involve him in anything unless forced.
I don't remember any big insights except that I'm pretty bad at estimates.

Everything that feels like a "half-day" task took an entire day or two. I would look back on every feature and think, "No way was I working on that for X days straight?"

Basically nothing takes less than half a day.
Elon Musk's Pro-Trump Website Accused of Shady Data Collection
You'd think that hammering the paper against the spinning drum would result in a blurry mess at best, but the hammers are fast enough that it works. It's the same principle as a chain printer such as the vintage IBM 1403, where the chain is zipping along at 90.3 inches per second when it gets hammered.
The naming of each seems intentionally chosen to confuse.
Are there "fuzzy" fingerprint algorithms that tolerate some variation in pixel color / hues, edges, imaging quality, etc?
Haven't seen the paper, but I'd guess the argument is something like "if the domain for x includes 0, then [edit: whenever x = 0] the Turing machine will get into an infinite loop looking for the first inverted bit[1]. _None_ of the three states will ever be provably true or false. If the domain _excludes_ 0 then you can prove that the machine will hit a non-zero bit in finite time, thus terminate, and either x<0 or x>0 will be shown true. But if you exclude 0 then you've also shown that the =0 state will never be true."

[1] multiple zero bits and a one bit is >0, multiple 1 bits and a zero bit is <0. Infinite zero bits (even if followed by a one bit) is +0, infinite 1 bits (even if followed by a zero bit) is -0.
I suspect that the “crap applications” issue arises not necessarily due to the method being wrong, but more likely due to people disregarding step 4 in the article: “Finally, once completely done, go back and perfect”.

It may be because of tight deadlines, lazyness (it’s “good enough” so why bother?) or eagerness to jump to the next project (because it is more exciting or profitable than doing the hard work of getting the details right).

I guess there is also a personality type factor that plays into it, because many people seem to just care about the hard requirements and cannot be bothered about things like performance, accessibility, design consistency, simplicity, maintainability, good documentation, etc., at least as long as nobody complains about it.
After reading the article, it made me realise this is why Power Automate and most of those low-code platforms are inefficient as they force you to do things "loading bar" style.
Damn this looks dope, shared with friends, sadly a lot of the links are down!
Braid, Anniversary Edition 'Sold Like Dogs**T,' Developer Jonathan Blow Says
Do you engage in any kind of physical archiving? I'm not going so far as to say it's superior to digital archiving but it does simplify maintenance of the assets in the event that you're incapable of it.
Almost, the hammer strikes the ribbon and the front side of the paper. The drum is behind the paper.
How the Music Industry Learned to Love Piracy
I have done something similar on the past and I was very happy with the results. At the time I was starting up a consulting business and got the first few gigs directly from engagement with my blog.

I also time boxed myself when writing. I wouldn't write unless I had a really clear topic in mind, then I'd give myself an hour to get it published. A few times I ran out of time and ended it with a "follow-up post coming soon to dive into ___" type message and that worked just fine.
Ask HN: What tools/methods do you use for rapid web prototyping?
Since I have a lot of time and ideas on my hands, I try to prototype my ideas as fast as possible because I don't want to forget the inspiration that caused them.

What are your tools for backend/frontend/database design?

My current methods are:
- live-reload on both backend and frontend
- dividing work days into backend+db/frontend only
- LLM prompting for small tasks/snippets

For stack related advice, my current stack is:
- backend: Python(Flask)
- frontend: JS/Bootstrap
- db: sqlite
> Once the Wheel of Time grows past a certain point...

Oh, wait, you weren't talking about Robert Jordan's fantasy series.

My bad. Yet another proof I'm old, yet another acronym to re-learn to keep up with the times... Sigh.
> Your original response of "it has few citations so it's unremarkable"

I'm befuddled. it's right there at the root of this string of comments: my original response was "it's unremarkable because it's niche in a niche area". it's only when someone asked why, i responded with citations and etc. so my original comment was not NPC according to your assessment, and it's only in response to someone reasserting that i had to cite something.
Windows programming has a natural job security dependency that is often overlooked.
Imagine what HN would look like if we felt the tiniest bit of solidarity towards other workers.
Depending on where you are based, maybe the companies tend to cater to a younger set of developers - few people in their 40s and 50s only have 8-10 years of experience. There are a lot of cases of ageism - it's not explicit but shows in "cultural fit", etc. All that said, I know older people at companies like Microsoft, Salesforce, even smaller startups, etc.
Automating away the boring parts of my job with Gemini 1.5 Pro and long context
It's because someone submitted it and more people voted on it. Things often take time to get randomly noticed by someone who also happens to habitually submit things to HN.
The mother knew (from experience?) that she did not have the necessary impulse-control, or intrinsic motivation, to save money for such a long-term thing as a dowry.

I was really taken by this example because my initial reaction was "just try harder". My first-world perspective has always been "if you failed, its a personal short-coming. You need to become better".

This mother's solution is based off a fundamentally different philosophy; "I am not capable of that kind of self-control. I'll modify the environment".
Honestly sounds kinda nice. Sometimes, C
caffeine lasts too long.
> Undefined behavior (commonly abbreviated UB) is a runtime concept. If a program does something which the language specified as “a program isn’t allowed to do that”, then the behavior at runtime is undefined

Importantly, UB is a runtime condition in the general case, in the sense that it cannot be statically determined (again, in the general case). It may depend on input data, or detecting it may amount to solving the halting problem.

A consequence of that is that UB cannot be caught by static tools in the general case without changing the language so that a large class of previously valid programs (i.e. not containing UB) become invalid.
I'm curious what the actual marginal cost of an additional pound on the shuttle is - surely you can't just divide?
Well, that's because it is how you draw an owl. You start with basic outlines to define size, pose and proportion, then you divide those outlined areas into smaller sections that locate important details like eyes, beak, ears, wings, etc. then you add rough detail to those parts which further breaks it down and you keep iterating like that until you fill in all of the fine details.

You can see the process here https://youtu.be/UGVOE2eHl0I
What was the XC2064 used in, as far as like commercially available products or similar, if you know off hand? I know some network cards and things like that have FPGAs.
The drum for the Shuttle teleprinter replaces 10 ASCII special characters with symbols that are more useful to the Shuttle, such as Greek letters for angles.

Specifically, the characters ;@[\]^!"#$ are replaced by θ~αβΔ.

Sigh... This ancient printer could render them, but apparently the Chrome browser on my modern Android cannot.