skysight-inc/HackerNews huggingface dataset:
You believe correctly
I think the claim is that earlier founders did colonize the world before the final group left and also colonized the world. Land bridges disappeared as the last ice age came to a close, making later attempts more difficult
> If you define failure as a form of victory then success is inevitable.

No, you can also do just enough to slumber away in mediocracy forever.
Running FreeBSD 14.2 on a Uptime Industries Compute Blade with RaspberryPI CM4
Crunch doesn't have any of these. That's CHICKEN you're thinking of, but CRUNCH explicitly does not require CHICKEN.
What should I be looking into?
> There is no need to bypass them when you can just solve them.

There is no need to solve them when you can just bypass them.
Right. And the fact that a BMW 2-series exists means that BMW can't sell all the 7-series' that they want.

They're cutting down 4090s into 4080s to fulfill a demand for a cheaper chip, while still supplying their premium option. Your fanciful world concept of things being sold for no/minimum margins is just that: fanciful.
Its not the same frequency range. Most cellphone networks use frequencies roughly between 500-3000MHz.
> Honestly, my controversial take is that for APIs, it would be cleaner to not use any HTTP status codes other than 200 and have all of the semantics in the body of the response.

We've been doing that for 20 years with json-rpc 1.0

--> { "method": "echo", "params": ["Hello JSON-RPC"], "id":1}
<-- { "result": "Hello JSON-RPC", "error": null, "id": 1}

In this context, HTTP is just the transport and HTTP errors are only transport errors.

Yes, you throw away lots of HTTP goodies with that, but there are many situations where it makes more sense than some half-assed ReSTish API. YMMV.
https://fidoalliance.org/fido-alliance-publishes-new-specifi...

I'm not super worried.
Both of those happen in the context of web browsing rather than existing in APIs in a vaccuum; I'd argue that there's absolutely no reason why the mechanism used to request a webpage from a browser needed to be identical to the mechanism used for the webpage to perform those actions dynamically, which is pretty much my whole point: it doesn't seem obvious to me that it's useful to encode all of that information in an API that isn't also being used to serve webpages. If you are serving webpages, then it makes sense to use semantics that help with that, but I can't imagine I'm the only one who's had to deal with bikeshedding around this sort of thing in APIs that literally only are used for backends.
頑張って下さい

Can you believe that my place was proposed for ITER (the big international fusion reactor in France), and is still proposed for DEMO (the next step after ITER)? We are struggling to find a few dozen people and somehow the Japanese government wants to build a huge project that will require hundreds or even thousands of people.

These guys want to build a huge factory in Hokkaido, good luck to them.
I paid $1700 USD-ish. I'm aware many products have a higher price in AU but that's pretty extreme! :)

OTOH, dark skies plus a view of the southern sky is something to be jealous of. :P

Earlier this year I was in eastern AU (and visited the Anglo Australian Telescope-- an amazing instrument). I was impressed by the skies there, I can only imagine what it's like out west without Sydney right over the horizon.

Very recently CMOS sensors have caught up with cooled CCDs for many purposes and have the benefit of being radically cheaper. There are a couple of vendors with products in the same ballpark as DSLRs with similar sized sensors (though obviously without the benefit of being particularly useful as stills cameras). or hum, are in the US at least. :P

The benefit of the cooled sensor is increased with darkier skies too, due to the relative ratio of sensor noise to sky background shotnoise.
> Even redirects aren't necessary if OAuth is implemented in a browser-less or embedded browser fashion, e.g. SFAuthenticationSession

Can you please expand on that or give me some hints what to look at? I have never heard of this before and I work with Oauth2 a lot.

When I look for SFAuthenticationSession it seems to be specific to Safari and also deprecated.

I always share this article because people overimplement OAuth2 for everything, it’s not a hammer: https://www.ory.sh/oauth2-openid-connect-do-you-need-use-cas...
Nihil novum sub solem.

Which means, nothing new since Sun was bought out.
Ive been running matrix for small company/group for almost 10years. No need to use Synapse as there are many other solid servers (and have been for years). Matrix (the company) software like Synapse and Denderite (their “performant” server in go) are aimed at mega servers that federate and the features revolve around that.

If you want to selfhost just make it easy and get Conduit. Its single binary and uses embedded db (rocksdb or sqlite). I cant say about federation but for private chat server this has been solid for me for years. I still run it with sqlite (worse than rocksdb) and with 30 very active people its more responsive than Synapse ever was.
I mentioned it in another comment: I am working in Aomori and my company struggles to find qualified engineers because few people want to live here. The climate is a MAJOR issue.

Kyūshū looks like a much more attractive option.
It sounds like a config dictionary with a continuous pipeline and good integration into design tools to me. UI design decisions are rarely artifacts in any deployment pipeline, so more power to the design team then, which is a good thing imho.

I know many companies (enterprises) that actually have this problem of scaling a design change up to 50 apps. These apps are either new products, rewritten parts, outdated "legacy", or stuff that has been outsourced previously. Now these companies are in demand for "rebranding for the digital age". It all depends on how well design tokens integrate into those situations and its used design tools.

A problem I see is also that such enterprises rarely make use of a better ratio than having 2 designers for the whole company, which then, in turn, suffer from opinion overload by various stakeholders. The UI design process produces visual artifacts and good designs always feel simple. I seen it various times that stakeholders therefor wrongly conclude that the design process must be simple, and that's the never ending circle of a designers life. That brings me to another concern...

Since design tokens open up the automation possibilities with specific design pipelines that might find their way into a deployment to production, and it isn't uncommon stakeholder-thinking that "designs are easy" - all that while LLMs are on the rise, mind you - I can also imagine some kind of horror scenarios finally playing out, especially when changes aren't well tested (responsive design, accessibility etc.).
> Progressive income tax is also silly. Just because you earn more money than someone else doesn't mean you derive more benefits from the government

Ok...

> Federal taxes should be a flat percentage, no deductions, no credits, no so-called "loop holes"... nothing. Every citizen pays the same percentage (whatever it needs to be).

Flat percentage? A flat percentage means that if you earn N times what someone else earns you pay N times as much tax as they do.

But you just said a couple of paragraphs earlier that just because you earn more money that someone else doesn't mean you derive more benefits from the government. If that's going to be the basis of your tax policy shouldn't the tax be a flat amount?
So, it's just a password manager that doesn't show you the password? With pwdhash it's difficult to fill things manually too.
> The impact on their server is barely anything. Itty bitty fractions of a penny. So the amount we need to respect their wishes specifically for burden reasons is negligible.

I don't think you can amortize "burden" across the number of consumers like that. If you want to take that approach, then you also seem to be arguing that the more people who see you in public, the less your likeness is worth--but I think empirically the opposite is true.

> Control over your own likeness is not "burden", but it's important too, and in this situation I would say it's orders of magnitude more impactful and important than the server costs of a few seconds of viewing.

But, why? If the marginal cost of someone taking a picture of you is next to nothing, why is control over that more impactful and important than server costs, for the same duration of viewing? If the marginal burden of someone viewing your likeness is approximately 0, and you're weighting the producer's preferences by that marginal cost (below), does that also not imply that the more people who see your likeness, the less your wish for control over your own likeness matters?

> The reason they set it up is not for selfies, so I think the marginal cost of selfies is the right metric. But even if we look at total burden to set up the system, that's divided over a ton of users, so the person taking a selfie is still looking at a minuscule fraction of it.

Again, I think this is the wrong way of weighting it. I think the preferences in general are an indivisible quantity, and the same regardless of the number of people must decide whether or not to respect those preferences. It's a preference, and each potential consumer must decide for themselves whether or not to respect those preferences. Having more consumers does not "cheapen" the weight of a producer's preferences for the next marginal consumer.

A model in which you weight preferences by marginal burden subsequently cheapens all preferences based on the number of potential consumers of the thing you're sharing. This makes no sense, and empirically--as in the case of "control over your own likeness"--more consumers seems to make that preference even more important. By amortizing the weight of preferences across the pool of potential consumers, you're essentially arguing that if your likeness were to be made available to everyone, for free, your own preferences regarding control of your likeness would become irrelevant.

I don't necessarily think that all preferences are equal, but I also bias towards weighing everyone's preferences as worth respecting, unless there's a compelling reason to assign more or less weight to those preferences. For example, when preferences are legally protected or morally aligned, I tend to weight them more; while preferences that are simply asinine or I consider to be immoral are similarly downweighted. I don't feel like this is a radical viewpoint, though?
Forest Service: cut Christmas trees on public lands (with permits)
why so aggro boss
> The iGPU on Strix Point can do 9tflops of good old fp32. Unsure what the TFlOps drops to on the new Jetson here as it goes from INT8->FP32. But probably still has a very healthy lead.

Not as much as you think. Per their developer blog [1], it only has 17.1 FP16 Tensor TFLOPS, so about neck and neck w/ the even the last gen (7840/8840) Radeon 780Ms.

The Orin Nano Super looks like a neat little board at a great price ($250) and wattage (25W), but basically if you are doing FP16 inference, it's more incremental than revolutionary - vs AMD it's a bit cheaper (7840 miniPCs are as low as $400 atm, there's an upcoming SBC that's launching at $330), a bit more efficient (you'll probably need 30-45W to get the max perf on the AMD board), and with better INT8 (note the 67 TOPS is sparse, it's only 33 TOPS of dense INT8), but w/ the AMD boards you can get a lot more memory (you'll need to use UMA to access it). Strix Point's NPU can match on INT8 perf, but those minipcs are selling for like $1000 and I haven't seen any SBCs so not very good price/perf there yet.

As another point of reference btw, since the Orin Nano Super is using (32) Ampere Tensor cores @ 1020 MHz. A $170 RTX 3050 has 72 Ampere Tensor Cores @ 1470 MHz w/ 168 GB/s of MBW (6GB VRAM) @ 70W. You'll expect 1/3 the compute and half the inference perf. Again, not bad for the power envelope, and a better form factor, but you aren't really getting much for "free" so to speak.

As a performance target (more MBW, more FLOPS), I'm more excited for Strix Halo and Orin Thor as a better fit for inferencing bigger models, but it seems like both AMD and Nvidia are going to continue charging an arm and a leg for those new products.

[1] https://developer.nvidia.com/blog/nvidia-jetson-orin-nano-de...
Yup.

I also dislike Grammarly because they made it unnecessarily difficult to cancel my yearly subscription. Instead of allowing me to cancel on my own, they forced me to start a thread with their support team, which felt frustrating and inconvenient.

Additionally, I found Grammarly’s approach a bit aggressive, and it often conflicted with other plugins.

ProWritingAid is another plugin that was awfully buggy.

I switched to LanguageTool, which I genuinely love and support. However, to be honest, I’ve always felt that basic features like grammar checking, proofreading, and editing should be built directly into the operating system, rather than requiring additional plugins. Even LanguageTool isn’t compatible with every app, which can be limiting.

Thanks to advancements in LLMs, I’m finally hopeful that this functionality will become standard, eliminating the need for tools like LanguageTool altogether.

That said, it’s probably a long way off, especially considering how lackluster Apple’s AI capabilities have been so far.
That’s what I say! Most companies think like this but say otherwise and receive praise or at least neutral stares. It’s almost like honesty is punished and deceiving is not.
Yeah, but it’s not an even sharing of resources. LLMs are consuming a vast amount of human attention (no pun intended) at the expense of technological pursuits that will more certainly generate value. As far as can be told LLMs are reaching a plateau in terms of real world value, batteries and superconductors have calculably more potential.
IRC is often romanticized, but after working with its protocol spec, I found it rather unsavory. Its unstructured message format looks like this:

:User1 PRIVMSG User2 :Hello, are you receiving this message?

While this might look fine at first glance, the lack of more regular structure caused issues. Some messages are easier to parse than others. Each implementation introduced quirks and variations, creating countless edge cases and hairy parsing code. To be fair, IRC _was_ a product of its time... but s-expressions were invented in the 1950s, so adding more structure and rigor to the messages wasn't out of reach.

My memories are from a long time ago so I may be overreacting... perhaps the Ergo authors can comment on their experiences if they are around here! I heard about IRCv3 but I doubt that effort solved most of my main gripes with the protocol.

If I were to work on a messaging app today, I'd look elsewhere for inspiration. From a quick search, it seems there's room for a modern and _simple_ protocol for chat, simpler than XMPP or Matrix. Essentially, we need a protocol that is for messaging what Gemini is for HTTP. Stretch: squinting a bit, the NATS client protocol looks close to a starting point for something like that [1].

--

1: https://docs.nats.io/reference/reference-protocols/nats-prot...
Look under the hood sometime and witness the lovecraftian horror. You can enable the electron dev console via env var. Everything from how they layout the page, to the underlying structure for messages and threads (and how they are accessed) is super complex.
Fully agreed, but let's not forget the psychological quirk of Discord moderators loving to divide the world into neat little boxes, so the mark of any established server is the myriad of different topic channels.

Every single community has become a silo with their own memes channel. It's like they emulate modern social media websites where they try to keep you engaged and in one spot forever.

I find it dystopian and power-tripping personalities trying to invent rules upon rules on their little kingdom is really not conducive to spontaneous socialisation.

Now, sorry, you cannot contribute to this conversation because you haven't fully read the rules on #welcome, didn't complete the captcha from our bot and, worse of all, you have not chosen a role for yourself.
Speaking of 70s, my personal showstopper for vi isn't mode switching (actually, quite convenient). It's the cursor being on top of a symbol, rather then between symbols, so you need to mind when to 'i' and when to 'a'. And no, virtual spaces doesn't change much, the whole editing model is built around it.
The role of the spec is to have alignment throughout proprietary and open source toolchains, from design tools to CI build scripts to UI frameworks, so everyone working on an experience can speak the same language, have high fidelity end to end, and reusable automations.

The idea that this can be solved through accountability doesn't scale in my experience. So much of this work is maniacal and low-value, there's very little incentive for teams to prioritize it... But in aggregate, UI inconsistencies bring death by a thousand papercuts.

Companies with design infrastructure teams and mature design cultures have automations in place. The goal is to bring such power even to those without design infra teams and early on their design maturity journey.
> Beyond this, if you want to determine causality, e.g. whether events are "causally related" (happened before or after each other) or are "concurrent" (entirely independent of), you can look at Vector Clocks—I won't go down that rabbit-hole here, though.

If anyone want to go down that rabbit hole: https://www.exhypothesi.com/clocks-and-causality/
The documentation is rendered without running the notebook in my case, because we store notebooks with all the outputs, so the doc builder (Sphinx) just converts them to HTML as is.
My comment was /s of course. JavaScript from 2000-2010 era can do wonders especially if you leverage modern APIs and enormous performance of modern browsers, instead of silting it up with transpilation, frameworks, and layers of modules. Unfortunately simplicity is signalling a beginner and amateur in enterprise working environment.
What if LLMs are a dead end?
A lot of this article seems to be conflating two things:

1. The ability for the code to process the error and recover from it
2. The ability to sensibly log, trace, and later for a human to understand the error after the fact

The later of these is best handled by using a tracing library systematically throughout your code to spit out open telemetr and “logging” the error within your local span. You can then debug the problem with a tool like honeycomb which’ll give you a much clearer idea of what’s going on. Having tracing in place will also help you debug in cases where you don’t have errors but your system is running slowly, doing something unexpected, etc.

This greatly reduces the problem domain you have to solve in actual error handling to just having the computer recover when something is recoverable. And in these situations it turns out that most recoverable errors are best expressed as “non-errors” once they migrate any distance from the origin of the error (e.g. the record not found turns into a standard “user not known” status return value - it’s no longer an error, but an expected behavior of the system!) So for these “short lived” errors that are either handled locally or bubbled up all the way to the top and never handled, I’ve found that Go’s native basic error framework is fine.
Yes, OS/2 had DPMI support starting from version 2.0, already in 1992.
I did say exo suits are already a thing, not sure how that negates the argument
lol. Reminds me of the story of the couple that went to vegas. The husband gets mad when he finds out his wife spent $200 on the slot machines. She points out that he lost $3000 last year's trip, but he retorts "Yeah, but I know how to gamble!"

So... they have working bullet trains.
pwdhash does that for passwords - binds them to DNS name.
Hmm, I was expecting more of a discussion on HN for this release.
I have so many question and no answer in the comments because nobody commented :P

What is this poorly documented reasoning_effort parameter and how can I use it?

Why is re-enabling markdown part of the prompt and not a parameter?

What's going on with this developer message vs. system message?

Any thoughts about the model spec's chain of command? https://cdn.openai.com/spec/model-spec-2024-05-08.html#follo...

Please HN, don't make me use X.
Hydrogen is already the cheapest it will ever be, as it's made primarily from natural gas.

There's of course so-called white hydrogen:

https://hydrogeneurope.eu/excitement-grows-about-natural-h2-...

But known reserves are really small compared to those of natural gas.
Have not heard of that, but is it similar to the Solid project / other personal data warehouse projects?
I'm not on Linux but if others want to contribute / are very interested we can definitely make that happen!
> Mobile devices are not supported for now. Please use the PC version.

Are you f&$king kidding me?
I genuinely don’t understand why you think nuclear is a viable alternative.

You agree it costs more, is less flexible, takes longer to be operational than renewable energies.

You didn’t present any good argument for nuclear except “something something you don’t like my politics”

I agree with GP that nuclear is often used as a smokescreen to delay doing __anything__ practical and instead keep burning coal etc
> macos leans so heavily on readline input

The ubiquity of readline is a bit of a myth. What happened was that Bash (thus Readline) and NeXT (thus MacOS) independently copied Emacs keybindings, where Emacs predates both. But the Mac GUI doesn’t use the Readline library, and differ in some points (e.g. M-f works in Readline but not MacOS). Moreover, it seems a lot of people think Readline is used everywhere in the CLI, but many popular interpreters use other libraries. For instance, Bash uses Readline but Zsh and Fish uses their own things. Python has used Readline up until now, but is moving away in 3.13. IPython switched from Readline to prompt_toolkit many years ago. Readline was also not the first shell to adopt Emacs keybindings, it was preceded by Ksh IIRC.

I have nothing against Readline, and I understand where you’re coming from since this is often repeated online for some reason. I just want to point out that it’s actually emacs keybindings and not readline keybindings that is the correct term here :)
>I never understood commenting out code when you have version control. I get why people do it,

I'm not suggesting that one should comment out code but I never understood why if they have version control and there is a new bug a significant amount of devs do not actually go through the history to find the working version.

Now - after writing the above and thinking while writing, I am going to suggest scenarios when you want to comment out code.

You write a great bit of code that does not work, you find out it is because API X is not correctly implemented, therefore you have to do a workaround kludge until API X is correctly implemented.

What do you do? I think the optimal solution there would be to comment out the great bit of code above the workaround kludge with a comment - API X has a bug, I have made a bug report out on the API X working group. I suggest checking periodically and then getting rid of the kludge and moving this code in. Dated, so that people can see when they should check.

It's true I have seldom had the pleasure of working with people where this optimal way of doing it would have been at all useful, but it has happened maybe twice over many years. Probably it will only help you out when you see the comment over the coming months, or when you get an email that your bug has been fixed.

I'm sure you can imagine other similar scenarios in which commenting out the code makes more sense than using version control.
Haven't seen anything personally that's as intuitive / easy to use as this one, but I'm biased
Go ask ChatGPT how to make a room temperature superconductor