skysight-inc/HackerNews huggingface dataset:
I've been aware about the unum stuff for a while, but I've never delved deeply into it, and some of my hot takes on it:

* Gustafson's unum project seems to be invariably pitched in a cult-like this-is-the-one-true-way [1] manner which makes it hard to evaluate dispassionately.

* There seem to be several versions of unums, the latest of which is not-even-a-unum anymore but instead a regular floating-point number with different distribution called 'posits.' That Gustafson seems to have changed the vision so many times suggests to me that early criticisms were in fact correct.

* Conversations I've had with numerical experts about interval arithmetic is that it generally doesn't work [as a replacement for where we use floating-point today]--intervals tend to blow up to infinity, especially as it's difficult to account for correlated error (which is the point of this article here, actually).

A lot of Gustafson's pitch seems to be "you shouldn't need a numerical analyst to write math," which is naturally going to rile up a numerical analyst (like Kahan). But the numerical analyst's retort that you're still liable to get into trouble if you're not savvy enough to know the pitfalls is equally true of Gustafson's proposal; there's no magic bullet that makes problems go away.

From my perspective, the real problem is that we lack the tooling to let programmers discover issues with their numerics code, no matter how they're implemented. Gustafson and Kahan are talking past each other on this problem, with Kahan rightly pointing to all the functionality that IEEE 754 added to enable this functionality, and Gustafson rightly pointing out that those features are unused and largely unusable, and Kahan (probably rightly) pointing out that unums' promise of a magic bullet to numerics comes with issues of its own.

[1] This is possibly meant just as a joke, but it's the kind of unfunny joke that instead makes me wonder about the character of the person who presents it, like how asshole-as-a-character internet personalities turn out to frequently also be assholes in person.
Bad news for dark matter: This data doesn't fit at all [video]
Yes because without an LLM I don't do it.
Daily multivitamins do not help people live longer, major study finds
I honestly just want a good AI vector icon generator. An i2i one, not just text prompting one.
Very interesting product. What is the license for the images generated with your service? Can they be used as designs for a commercial game?
When the end result has actually happened (advocacy for the avoidance of sound-alike words), it is no longer a slippery slope.

Anyway, there is value in trying to get people to understand that people who innocently use a sound-alike don't intend to offend them. Which is pretty much what John McWhorter has written about many times. The failure to understand context seems to be a big part of many issues of the day.
only if there are cookies
Fun challenge: userscript to make an animated fire out of checkboxes
Cows in America derive most of their calories from corn. And while most Montana cows generally live on land unsuitable for crops, Montana only has a small fraction of American cows.

And I believe that your comments are even less true in other prominent cattle producing countries than America.
Because I've heard of enough lazy uses of LLMs to be suspicious. Auditing the program means being sure that the info pulled from those documents is reviewed properly. Also, a complete lack of regard for other people's privacy.
> Can we make “the simplest form” of tracing garbage collection work for systems programming?

No. 24 bytes per allocation and having to perform a copy and point fixup is too expensive.

The problem with GC is that it’s fine until it’s not. And when it becomes not fine you need to radically change your entire architecture. There is no incremental fix.

That said, Unreal Engine does in fact use a mark-and-sweep GC for certain types of objects. Which could be something for the author to look into.
or the defensive maneuver

window.addEventListener("change", function(e) {
if (e.target instanceof HTMLInputElement && !e.target.checked) {
e.target.click();
}
});
I think that is what happened. From the SEC press release:

> As part of the settlement, Terraform agreed to pay $3,586,875,883 in disgorgement, $466,952,423 in prejudgment interest, and a $420,000,000 civil penalty.

I had to look up disgorgement (https://www.investopedia.com/terms/d/disgorgement.asp), but it's repayment to those who lost the money.
Out of curiosity, was your correspondence in reference to navigating the federal government’s services, or were you corresponding to share your concerns about political matters?

It seems like the congressional offices can be useful for bringing exceptional cases to the attention of the various federal bureaucracies, from taxes to passports to capital tours.
It's a shame you're being downvoted because you make a fine point - Thomas' ethics aren't really at issue w.r.t. the ruling here, since it applies to local officials and not people in the federal government.
According to [2] 35.7 million tons of plastic waste is produced per year, and 0.61 million tons are exported.

That leaves 35 million tons, and with only 5% being recycled, there's plenty of plastic left to go into 'rivers, oceans, everywhere'.

[2] https://www.smithsonianmag.com/smart-news/the-us-recycled-ju...
The problem is you need to send 467k (current count of checked boxes) websocket messages and backend(s) are already dying for ~1 hour. Good luck with that, I only played for some time by clearing first 1000 boxes every few seconds.

Even after you send those 467k messages they need to be sent to (I assume) few thousands browsers each, so you need to wait for 467M messages to go through :D
Which I think is also unsurprising, it takes the insanity of Adobe to want to claim your customers work for you.

But this is exactly the type of situation why you have a contract. Even if it is standard, this is the means by which you can enforce the AI company to not use your data.
AI safety already is double speak. The primary meaning is "safety" for investors who don't want to be associated with something distasteful. The other meaning is basically a thin cover.
Interesting concept. Just wondering, how does it stay updated with the latest info?
Multivitamin myth: Study shows no benefit to long-term health, longevity
Same as all of those other languages mentioned. What gives you the impression that Go is somehow magically different? Or have I misinterpreted you?
May be a feature for SK. Send aid to kill two birds with one stone?
Cheaper than an Apple Pro Display XDR ($4999 to $5999).
Is the announcement just that they're on the AWS marketplace for govcloud? Do people ever actually make use of AWS marketplace? It just seems like a way to skirt procurement.
303 Creative was not prosecuted under Colorado's law. They were not even asked to create a wedding website for a gay couple: https://newrepublic.com/article/173987/mysterious-case-fake-...

In fact, there is no evidence they had ever built a wedding website: https://slate.com/news-and-politics/2023/06/real-story-behin...

So, we have someone who has never suffered a harm from the law, was under no risk of prosecution, and who had never even had the opportunity to violate the law. If this person has standing, then standing is meaningless.

The fact that there's a blurb about it in a decision is irrelevant, does the court have a consistent philosophy on standing, or are they just winging it? It seems really obvious they're winging it.
> the code that is currently executing can be manipulated live

Typically when people say this about Lisp, they mean that they can redefine functions and objects live, having all the code adapt to use the new definitions, or when their code hits an error, they can not only redefine functions and objects live, but also examine the state of the call stack and change the values of variables live, and then let the code run again. This[0] is a clear explanation that I found. There's also a video[1] that shows the same thing.

However, I don't know if those apply to Scheme. Also, I am pretty sure it is unrelated to Lisp being homoiconic, and that it's more about it being dynamically typed and interpretable.

[0]: https://malisper.me/debugging-lisp-part-1-recompilation/

[1]: https://youtu.be/jBBS4FeY7XM
I could stand to hear more about this. What problem were you running into?
Speaking generally: The program doesn't always have to give correct results. The program just needs to reduce 30k documents down to 200 documents for human review.

You're comparing LLMs to a hypothetical alternative where a human reviews all 30k documents in detail. But the real alternative is often just a worse quality sieve where more errors blunder their way through the existing flawed processes. LLMs can improve on that.
The last I heard, ”expediter” services game the passport offices the same way.
Re Humane Ai Pin - did you never receive it because you cancelled your order? Or did you never onboard? There's a bit of an unusual process with ordering the Ai Pin where it won't ship until you "onboard" i.e. set up your account/service with Humane
> worked with groups spearheading a campaign to pass so-called “anti-BDS” state laws

What kind of groups did they work with? What kind of work did they do with them? For all I know they're funneling money to non-profits owned by family members of government officials.

There is nothing concrete here.
The IRA started out adding $80b to IRS funding, and Republicans negotiated it down to $60b.
I can imagine that for many government tasks, there would be a need for a reduced-censorship version of the AI model. It's pretty easy running into the guardrails on ChatGPT and friends when you talk about violence or other spicy topics.

This then begs the question of what level of censorship reduction to apply. Should government employees be allowed to e.g., war-game a mass murder with an AI? What about discussing how to erode civil rights?
Any sense of speed? My assumption is that shuttling the weights in/out of the GPU is slow. Does GPU load + processing beat an entirely CPU solution? Doubly so if it is a huge model where the model cannot sit fully in RAM?
Stacks printed by the receiver are generally incomplete/useless for systems that communicate. The error is often in the sender, but is reported by the receiver. This isn't unique to Go and channels.

Consider a Node app that calls a C++ web service. The C++ web service returns "503 Service Unavailable" because your request causes the server to segfault. The useful stack trace for fixing this problem is on the C++ side in a core dump, not whatever Node prints when the HTTP request fails.)

What you want to do on the Go side is have your sender be able to relay an error to the receiver, and to wrap errors:

func doWork(w work) (result, error) {
return errors.New("too lazy to do work")
}

func doWorkQueue(q <-chan work, r chan<- result) {
for w := range q {
result, err := doWork(w)
if err != nil {
r <- errorResult(errors.Wrapf(err, "doWork(workID=%v)", w.ID))
continue
}
r <- successResult(w, result)
}
}
...
go doWorkQueue(...)
submitWork(work)
for r := range resultCh {
if err := r.Err(); err != nil {
log.Error("failed to do work: %v", errors.Wrap(err, "recv result"))
}
}

This now errors with something like:

main.go:20: failed to do work:
main.go:20: recv result:
main.go:9: doWork(workID=42):
main.go:2: too lazy to do work

Or if your `errors` library doesn't grab the caller func/line number, just "failed to do work: recv result: doWork(workID=42): too lazy to do work". This should be enough to debug the problem, regardless of what side the problem happens on.

(At work we use a hacked up copy of github.com/pkg/errors, which grabs the entire stack trace at each of the errors.Wrap/errors.New call sites. This results in an exceedingly verbose trace that takes up your entire screen, but is at the very least... thorough.)

The reason that error wrapping is essential is because stack traces don't capture critical information, like what iteration of the loop you're on, how many times your retry loop ran, which work id failed and returned "too lazy to do work", etc. The error wrapping is where you get to add this in. This is, again, the same as every language... the random exception you throw in your HTTP client when the server is down isn't aware of the work item id that caused this exception, so you have to catch and re-throw with that information or you have an undebuggable mess.

What's nice about Go is that it's really easy to add this contextual information, either with fmt.Errorf in the standard library, or with very small functions that capture some information automatically (errors.Wrap/errors.Wrapf). I will say that not doing this is my #1 complaint, and it's exceedingly common to just "return err". I have spent 4 years fixing the work codebase to wrap errors, and people still add new unwrapped errors (because our linter allows an escape hatch, errors.EnsureStack, which some people really like). It then results in some oncall engineer wasting a week debugging a simple problem. Sigh! But that's humans being humans; Go makes it very easy to do the right thing. You just have to tell your team to do the right thing and to make them want the right thing.
the fact that it hasnt been taken down in 2 hours makes me think insiders are deliberately doing this, either from tesla or youtube, what a total shame
It's a problem for values of all types, which is why exceptions are usually handled specially in other languages. I get that it seems impure, but everything you call has some way to fail <1% of the time that you probably want to handle very differently from any other outcome. It's sensible for a language to force you to either designate a different code path for that or let it bubble up (edit: which, to clarify, Golang does not enforce with error return types, which is what the other person dislikes about it).
I am confused by this comment. All the enumerated features are dependent directly or indirectly on the memory management approach that the system uses. If one chooses badly for the target workload, there are many things that will go wrong including excessive copying (which kills the performance of the system) and inscrutable crashes/logic errors as well as security vulnerabilities.

Personally, I tend to think that if you nail the memory management technique all the other items will tend to work themselves out. And I think this is actually harder to get right _systemically_ than all of those other things.
Arguing on the Internet is not doing your part.
my bet is on either "learned helplessness", or more likely they didn't actually care enough about the answer to look it up themselves, and were simply curious about it. Plus asking here also potentially puts the answer here for future people that were curious
Not so insane given that they are far more numerous due to agriculture than they would be as wild animals. This ultimately is a human-caused problem not a natural one. And there is the issue that what we feed livestock affects how much gas they produce. It's a serious research topic

https://clear.ucdavis.edu/explainers/why-do-cattle-produce-m...
Why does no one ever consider removing tax that doesn't make that much revenue? When I look at the tax code in the US half of it only applies to 0.0001% of people and the ones that affect the uber-rich have loopholes to avoid it. Why not just look at which tax is the most 'profitable' and remove the rest?
Porting is not enough. Valve succeeded because they made their layer “just work” for 90% of games by default.
You are not wrong. This ruling mostly just harmonizes the law as it applies to federal and non federal officials.

> The high court has long held that criminal laws restricting “illegal gratuities” to federal officials require proof that the gifts were given for a specific “official act,” not just because of the official’s position.
Implementing Role Based Access Control in Node.js and Express App
I don't think janalalcm is talking about the batch API, but just putting multiple profiles in a single API call.

If your prompt is short, it won't make much difference to the cost. But if your prompt is, say, about the same length as a single profile, you could save almost half your inference costs by analysing ten at a time.
How did you do your taxes a couple years ago?
Honestly, the platform is so new that we haven't started working on that problem yet. It is an addressable problem based on our stack, though.
It's all terrible working conditions and awful bosses until you have too much free time and have to start contemplating the meaning of your own life. Then you REALLY have hard work to do or succumb to the impending nihilism.
I think cache coherency protocols are less intuitive and less talked about when people discuss about caching, so it would be nice to have some discussion on that too.

But otherwise this is a good general overview of how caching is useful.
OK, so you have a way to evaluate the accuracy and convince yourself that it’s probably works as expected. But what about me, a user? How can I check that the question I asked was answered correctly?
Interesting write up. I am curious about the usage of this framework. One thing in reference counting’s favor is that it is hard to screw up. You just use the rc type and when it is no longer accessible it will magically get freed. That is how GC works in a high level language too, you almost never need to think about it.

Let’s look at the example from the docs:

SWL_GCArena gc = swl_gc_arena_new(<starting-capacity>);
int* foo = swl_gc_alloc(&gc, 5000, alignof(int), NULL);
int* bar = swl_gc_alloc(&gc, 16000, alignof(int), NULL);
int* baz = swl_gc_alloc(&gc, 3000, alignof(int), NULL);
// foo and baz are roots
SWL_GC_COLLECT(&gc, SWL_ROOT(foo), SWL_ROOT(baz));
// bar is gone, poof

If you try to access bar at the end you get a use after free. I am pretty sure if you tried to access foo again it would trigger the same problem, because it is a pointer directly to int and not an indirection. What happens if you pass a non-arena pointer to SWL_ROOT? What happens if you have multiple arenas and you mix and match them?

There are many ways you could trivially shoot yourself in the foot in large program. It is a lot less “idiot-proof” than simple reference counting. The fact that you create each piece of memory and then have to manually pass it back to the root macro on each collection is very similar to the “malloc/free” dance we want to try and avoid.

The rooting issue is something I tried to tackle in my GC for rust[1]. Essentially making low level GC "idiot proof".

[1] https://coredumped.dev/2022/04/11/implementing-a-safe-garbag...
And given the volume of data they likely sift through, I'd also expect them to want very small, high-throughput models for identifying targets for larger models to examine.

On the flip side, LLMs must give the NSA a new challenge: a flood of garbage text generated by no-one in particular. Perhaps there will be more effort to put surveillance directly on-device as tapping networks yields more noise.
Don't those coil packs distribute 10-20k volts?
This is interesting. I wish the other interactions were as dramatic as the drag one. You have to really crank up the brush size to see anything interesting.
I never did. Had to pay fines.
Regardless of the details which are of course important, a very very good game. Just pay attention.

Created by Lukas Pope who also created Papers Please (on Steam)

https://store.steampowered.com/app/653530/Return_of_the_Obra...

and the equally cool Mars After Midnight for the Playdate

https://play.date/games/mars-after-midnight/

Steam sale starts in ~20 hours,
If Figma is using OpenAI API on the back-end for this, does the data they relay to OpenAI get protected? (Not sure if they do, but curious if their solution is on-prem or being handled by a 3rd party)
It makes his grifting look and be less bad. It matters legally, as precedent is a big part of US law, and in PR, as he can claim it is not bribery because he has now defined it to not be.
(Disclaimer: I am a member of the Computer History Museum.)

We have the Computer History Museum in Mountain View (https://computerhistory.org/). While unfortunately visitors are not allowed to touch the equipment unlike the Living Computers Museum in Seattle, this is still a wonderful place for people to learn about the history of computing.

In addition, the Computer History Museum has many events, often free, where pioneers of computing are invited to give talks about their work. I’ve been to events that celebrated the Xerox Alto, Smalltalk, the Apple Lisa, and the original Apple Macintosh. I’ve met Dan Ingalls (Smalltalk), Charles Simonyi (Bravo and Microsoft Word), Marshall Kirk McKusick (BSD), and Donald Knuth at the Computer History Museum, and I’ve seen Adele Goldberg (Smalltalk), Jean Louis Gassee (Apple, Be), and even Steve Wozniak in attendance. It’s an amazing privilege being able to have casual conversations with people who have profoundly shaped society.

It’s truly a blessing that we have this important resource in Silicon Valley and that there is a stream of donors who help keep this museum alive. I wish the Living Computers Museum in Seattle had the same type of leadership the Computer History Museum has, but barring any last-minute interventions it may be too late to save that museum.
Yup! This is exactly how context.WithCancel is implemented; <-ctx.Done() is the signal that everything that cares about cancellation listens on. The returned CancelFunc just does `close(thatChannel)`.

I prefer explicitly using contexts for cancellation, but in a pinch:

c := make(chan struct{})
foo(c)
bar(c)
close(c)

is a useful pattern. (I do this a lot in tests that involve concurrency; the test calls t.Cleanup(func() { close(c) }) and then if the test fails with t.Fatal or something, all background work is killed.)
I see that they have bad design sense which I think generalizes to bad product sense and bad business sense.
discovering the grayscale filter built into Android & iOS now has been a huge help. Way more than I expected. Especially with everything in dark modes and making my homescreen/lock screen just a black wallpaper. Somehow it really helps to disable one of the reward feedbacks from phone use.
> Findings In this cohort study of 390124 generally healthy adults with more than 20 years of follow-up, daily multivitamin use was not associated with a mortality benefit.
There are ways how to create local account during Windows installation. It worked for me few months ago.

https://www.pcmag.com/how-to/how-to-set-up-microsoft-windows...
Searching for "XKCD 862"[0] finds implementations. I never found a good one for firefox.

[0] check the alt-text https://m.xkcd.com/862/ (2011)
Yup, 100% agreed. GC is a tool, we need to talk about specific GCs and their costs as to whether or not they're suitable for a particular task.

For me the main issue has to do with FFI and needing to drag around a hefty runtime to make a library available to other languages.

Not an issue with simpler GCs.
I've read a lot of code in my life. I see that exception handlers are sometimes used to carry errors, virtually always exceptions, but almost never anything else. Who is it that you are think are passing around email addresses and geocooreinates using exception handlers?

But even assuming it is done sometimes, is the developer going to actually handle it? I don't know how many times I've come across "catch" blocks that are empty or something equally inappropriate. Nothing was gained. It turns out that programmers will still forget no matter how hard you try to hold their hand.

I'm not sure there is any other solution than to test it, and once you get into testing, entire blocks of logic missing are going to stick out like a sore thumb. Forgetting an entire branch is not exactly a subtle bug. At that point it really doesn't matter what language constructs you do or don't have available.