skysight-inc/HackerNews huggingface dataset:
> This is defeatism and not true.

It is, though, as the problem is scarcity. So long as you have that, it is impossible to not end up in a situation where some people have things other people don't have. It doesn't go away simply by slightly changing the way people choose to organize.

> Worker solidarity, political awareness, and effective political work is the solution.

These are oft considered useful tools to help us achieve post-scarcity, but are not the solution in and of themselves. This is like saying that the hammer is the solution to the housing problem. Indeed, a hammer can help with solving the housing problem, but simply having a hammer doesn't get you there. You have to also hit the nail.
SBF Is Going to Prison, but the Fight over Money at FTX Drags On
I would like to see how it competes against command-r (non plus)
As a basic collectible game I really like this idea.

It would be nice if it was possible to trade or auction art after buying it, but the focus seems to be more on collecting new art which I respect.

Any planned features?
There was a time when drink refills were not free, you had to pay for another drink. The arugment was, they gave you straws so you would drink more and buy larger or more drinks.

At some point restaurants realized they could offer free refills as a competitive advantage, (or save labor and have customers fill their own drinks) and now everyone does it. At that point, straws were just something that was expected.
I'm not the strongest Go programmer, so maybe my inexperience leads me to still disagree with the ergonomics of "if err != nil" over something like a formal `Result`/`Either` type à la Rust/Haskell/..., but this is a decent bog post.

I think using a more structured capital-R Result type, combined with match/case makes for better structured code, and I can't help but think that `err != nil` is a bit of a smell left over from Go's initial decision to avoid doing generics (all of which is alluded to in the writeup).

I do disagree with the author using a trivial example to demonstrate that `err != nil` isn't that bad, since most code you'll work with isn't trivial. the errnil pattern obviously isn't enough of a problem to deter many companies, which I've always been interested in, since to me it always seemed like a brittle and awkward error handling mechanism.

All that aside, `blog.verygoodsoftwarenotvirus.ru` is an excellent domain name.
Avoid a Billion Climate Deaths
This, and most of the time if you’re simply bubbling up an error it’s busy work. Languages like python get out of your way here. If python was able to reliably tell you possible exceptions (within reason - at a certain level generic errors like out of memory can be ignored since they’re globally present) and provide a convenient way to handle them that’d be great.

This is domain dependent, but most of the time errors are handled by “catch it, log it, display an oops and move on”, and optimizing for that case is very pragmatic.
It is very uncommon that they are very strong, but they can be rather severe when a big one occurs.

https://en.wikipedia.org/wiki/1886_Charleston_earthquake
I'll add more art pieces, and you can also add yours too ;)
USGS suggests that this was a main earthquake of a series. I guess there was one mid march

https://earthquake.usgs.gov/earthquakes/map/?currentFeatureI...

This event is identified as the potential mainshock of an earthquake sequence.

From this URL: https://earthquake.usgs.gov/earthquakes/eventpage/us7000ma74...
Correct me if I'm wrong but that still won't have file names and line numbers, right? So not only do you have to remember to wrap correctly, you need to take care to keep "some context: " a decently greppable string.

I agree that wrapping errors that way is better than not, but I still find it a bit lacking.
Cloudflare acquires Baselime to expand serverless application observability
I was under the impression that containers/Kubernetes actually depend more on the kernel than virtualization as they run the containers by sharing the kernel? I may be misunderstanding it and need some HN knowledge power!
Rust does.
Intellij can also expand macro inline, But iirc you have to enable it in advanced settings.
Figma is pretty great at this.
how do you get that from just that sentence?
No mention of `errors.Is` or error wrapping? IMO that's where the pain starts.

I definitely agree that in many programs, when an error happens, you're done, you just blast up the stack and then the error message goes into a sentry report or gets logged etc.

But it's also still quite common to want to treat some error conditions as soft errors, or otherwise handle them differently. Now you're doing errors.Is and engaging with the poorly structured world of error wrapping trees.

Here's one I hit recently. One of my pet peeves is error messages like "unsupported thing". Ok, what thing was unsupported? Very often people just omit this stuff because it requires you to now cat strings, which is sometimes hard or cumbersome depending on the language. So, I changed my code to have the error be "unsupported thing: <thing>".

However, up the call stack, I want to handle ErrUnsupportedThing too. Because maybe there's some reasonable thing I can do to help the user make the thing supported. So I'm calling `errors.Is`. But wait, now I need an `ErrUnsupportedThing` variable to refer to. But each call to fmt.Error creates a new error that isn't `errors.Is`-equivalent to each other.

I ended up reconciling this by making `ErrUnsupportedThing` just be "unsupported thing" and then I wrap it by doing fmt.Errorf("%w: %v", ErrUnsupportedThing, thingType).

But now what if I want to say "ErrUnsupportedThing: <A sub-error that occurred>"? Well, hope you're using a recent version of go, because "%w: %w" only works in go 1.20 and later.

Also the fact that all errors are just "error" instead of being typed errors tends to make people a lot lazier about their error handling in general. In java, if I get a ThingNotSupportedException, I expect to be able to find a getUnsupportedThingType() so that I can explicitly pull it off the string without needing to parse. That's easy in Java, it's a subclass of exception. In go, now you're writing a "subclass" struct to implement error's interface, tacking on extra struct fields and stuff, and since nobody ever actually types their return values more explicitly than `error`, you're now doing casting/duck-typing to pull that information out. Etc.

I guess let me put it this way. Go errors are good for 80% of errors and fine for 95%. That's great. But the easy code is already easy! What irks me is when it breaks down when I get to the code that's actually a bit tricky to handle errors for. The type system, the error system, and everything is just like "wow good luck you're on your own". Whereas python/java/etc have my back here.
> Once Microsoft realized that the intruders had used a theoretically expired 2016 consumer signing key to forge tokens for an enterprise customer, it launched an "all-hands-on-deck" investigation that went through the night, June 26–27. The company arrived at 46 hypotheses for the intrusion, including "a theoretical quantum computing capability to break public-key cryptography."

I feel like this is a twist on the denial stage of grief. Sure, our house is on fire...but maybe it is because a asteroid just struck the earth.
Felt it in Southwest CT for a solid 15-20 seconds. Definitely thought it was a very large truck going by, but also felt like our solar panels were falling off the roof.
IFUNC isn't used directly to patch the functions of another library here, it's just the entry point for the exploit code. IFUNC is used as opposed to other ways to execute code on library load because it runs very early (before linking tables are remapped read-only).
YEEHAW!!!
I once experienced an earthquake in Connecticut.

The weird thing was, just before it happened I heard/felt a very peculiar thrumming in my ear, like the air was exerting vibrating pressure.

They say that animals can detect earthquakes before they happen. I think I might have an idea as to how.
I frequently do this in Notion, especially in more brainstorm-y meetings. Also good for notetaking; I might be writing most of the notes, but then start talking more, and see someone jump in to take my place in the notes.
> Being able to query the latent space of a large subset of human knowledge using natural language is the closest to 'intelligent computer' as we've ever come to.

I would agree with this statement, but it's still laughably far from it. As the other comment said, it lacks the ability to rank the veracity of the information it presents: it will present it in a grammatically correct way, but it has no way of knowing if the information it's presenting is accurate which explains ChatGPT's tendency to just make some shit up when you ask it things.

And in the odd event it is correct, it's simply digesting information from other sources, likely search engines either it's own or not. Again, this is not useless and not not-clever: however in that way it does remain pretty useless because of the above issues of accuracy. The best it can do is get you the most highly ranked information on a topic based on it's pool of knowledge, and that may or may not be the most correct one.

Also I'd add: these two issues compound one another, because the LLM is obscuring the source of it's information. You can have it add the link to it's citations, that would be helpful, but you don't know where it got those citations or why it picked them, and the LLM can't explain that for you. And, those choices were based on factors that are definitively not the accuracy or reliability of those sources, merely their ranking in whatever search algorithm is being used. Even if you presume this AI was trained on data relevant to the topic you're asking about, that doesn't mean it (and in fact, as I understand LLM, it's basically incapable of) understands that topic in a way that makes sense to a subject matter expert.

If you asked an engineer what size lumber would be required to construct a floor that could support a small vehicle, that engineer would probably have a rough guess based on their previous experiences, and further, could then do the work: research the weight of the vehicle, the situation the structure will be installed in, the environment it will exist in, etc. and come back with a solid answer to your question. An LLM, by comparison, would consult the writings it was trained on for similar questions, and create an answer it thinks matches yours. But what does "similar" mean here? Is the wood and the dimensions the same? Is what it's looking at based on a small vehicle or a cement truck? Is it looking for articles about structures in similar climates or did it pick some that were closer matched to the structure but in completely different environments? On and on.

Using an LLM this way takes the problematic aspects of googling things and basically factors them out, because now you can't see what it's googling, which results it's picking or why, and can't verify their relevance. How many times have you searched specific things and left a google result completely befuddled as to why on earth it included it? Now imagine that, except there's essentially zero chance the AI caught that, and it incorporated that irrelevant data anyway.
You Can Now Edit ChatGPT Images
This site is often fairly balanced, but I think the author often jumps to conclusions. The pinsyscall feature is one place where many security researchers have jumped to conclusions, because they only see it from their narrow x86 oriented view.

Yeah, on x86, I can craft a ROP attack that allows me to discover relocations for functions fairly trivially, especially for coarse ASLR, because I can read the text segment. But, ARM64 has execute-only support so that it's possible for code to execute, but not read, a text segment. In this situation, pinsyscall does add a valid defense in depth layer. It's still imperfect, but this does in fact raise the bar necessary to carry out a ROP attack when combined with randomized re-linking on boot ASLR. Further, once dynamic linking has occurred, the text segment for a binary is made immutable so that no mapping changes can occur, including mmap.

I think that OpenBSD still has a long way to go before all of these defenses align, but they are far less trivial than the author makes them out to be, because none of them are meant to be used alone. OpenBSD developer decisions like these can sometimes appear to be casting about randomly, because they are making small improvements instead of building toward a particular goal. Sometimes, they hit gold as with W^X, which was widely adopted. Sometimes, their ideas stink, like systrace. But, I don't think it's wise to just dismiss these ideas out of hand.

Instead, I recommend that people look to the history of OpenBSD, which has been more of an evolutionary approach to security instead of a revolutionary approach (i.e. Fuchsia). From an evolutionary perspective, pinsyscall makes sense as it is low-hanging fruit that can buy some security and can force applications to use a standard interface (libc) instead of making raw system calls. From a revolutionary perspective, pinsyscall just seems like a dead end. Revolutionary design has convergent effects -- all of the pieces come together in a perfectly engineered defensive shell. Evolutionary design has emergent effects -- fixes and features build on each other until they co-evolve into strong defenses.
> Is the market likely comprised exclusively of NSA fronts competing with each other

Nah. Clandestine spook fronts are low profile entities. When they've been pervasive, it was in a niche market.

> Do me a favor.

What's the favor?
Hannibal's Cunning Ambush
I felt it on an upper floor of a big old brick building in Cambridge.

First thought was it was an earthquake, but then no signs other than that I could feel it in legs.
I broadly agree that the BBC has a vested interest in demonizing non-capitalist systems, but home ownership rates haven't deviated terribly much for the past half-century.
As the author of both Slint and qmetaobject-rs, I wonder if you checked out Slint[1] and what were the reason you didn't pick it.

[1] https://slint.rs
> Is that falling out of style?

I'm a bit outta the loop in the pure FP world now, because I've been stuck doing Java and C# for the last 5 or so years, but I think that world is trying to move to an algebraic effects-style system. People keep trying to explain to me why that's "better" but I'm not really sold on it, because it just feels like we're reinventing goto, though generally when I have contrary opinions like that it turns out that I'm wrong.

I don't really know Rust very well, but I suspect it has a similar way of doing `map` and `bind` to handle downstream stuff, since it has functional roots. The biggest issue I ever had with it in F# is the fact that they don't really have a concept of a monad transformer and therefore you can't easily combine monads, so if you have to mix `async` and the `Choice` monads (more or less F#'s version of Either), you have to explicitly craft your own custom monad. It's really not that bad but it's less sexy than proper monad transformers.

Algebraic data types are so utterly useful that I get annoyed that it's not standard in every language.
That makes sense. I misread it somehow and didn’t make the connection of having a free of charge tier.
Yes a doctor. my mistake on the improper formatting.
They talk about voice samples, but they don’t mention prices for them

Would it be attractive for a company like Twilio or Aircall to offer free phone calls and sell anonymized recordings?
Speaking of the coverage of STEM stuff in NYT, here's another recent example.

https://www.nytimes.com/2024/04/03/technology/prevent-cybera...

> His job involves developing a piece of open-source database software known as PostgreSQL, whose details would probably bore you to tears if I could explain them correctly, which I can’t.
Interesting to see a "modern" ~30b sized model - will have to give this a try!
Functionally not that different from a listicle - and at least those aren't so concerned with sounding smart
reddit didn't help but didn't think of stackexchange. Thanks.
The point is, without a defibrillator (gun) you will have a very hard time to save life (kill) even if you wanted to.
To find answer to your question I recommend looking through relevant discussions, ref https://bbs.archlinux.org/viewtopic.php?id=294363 and elsewhere
This will be potentially comforting news to a young Alvey in Brooklyn.
https://www.youtube.com/watch?v=5U1-OmAICpU
> Drilling oil no reason other than to give people jobs

Here we learn that greed means a desire to give other people jobs. The things one learns.
Ironically this may have been true at one time but Amex is now one of the best card providers to deal with as a merchant as they have a very clear and transparent dispute and then appeals process. Visa/Chase seem to be impossible to win.
>I was showing why 30y-fixed jumbos exist as a result of F&F. You argued

I understood that. But showing that something is a result of something else needs some kind of logic, stating both things exist does not establish a casual relationship. You can try it for yourself by applying your own argument in the reverse direction: if your logic had been sound then it would also be true that F&F exist because of 30 years fixed jumbo loans.

>F&F can do that at the scale they do because they have an implicit guarantee. That creates securitisation

What? Securitization is turning something into securities, it's a process that is not caused by any guarantees, you can do it yourself.
The scaffolding-covered sidewalks in front of many buildings in NYC are a good reminder of that actually. I wouldn't trust the scaffolding to protect me if major parts of a building were to fall off in an earthquake however...
> Custom Search JSON API provides 100 search queries per day for free. If you need more, you may sign up for billing in the API Console. Additional requests cost $5 per 1000 queries, up to 10k queries per day.

It seems like that API has a limit of 10k queries per day, so I don't know if it would be feasible for Kagi to use and I thought most Google APIs were prohibited for use in a competing product.
why go to these lengths instead of offering containerization?
It a lot of factors but the main drivers are inflation and desirability. In places where the desirability is basically neutral, houses do what you would expect and “used” ones sell at a moderate discount to new construction.
Sadly, I think that is indeed radically different from Go’s design. Go lacks anything like sum types, and proposals to add them to the language have revealed deep issues that have stalled any development. See https://github.com/golang/go/issues/57644
You mean all your docker containers, right?
Sure, but as long as apple will play hardball like they're clearly doing, they could very well enforce app store rules as app signing rules and it'd be years before the eu would force them to stop, not even counting on the fact that current app signing rules are already insane.
What if this is just another foreshock?
Nothing therein compiles.
Yeah, that is what I was trying to convey with regards to the interest deduction being capped, not that the deduction just stopped. I think I was a bit muddled with my second point as I was trying to suggest by the time you are at a very high income level, your deductions are primarily made of other things, because the mortgage interest deductions can only be so large. That's indeed what the underlying data from the IRS shows as you go up in income past $500k a year comparing column 91 (total home mortgage interest deducted by itemized filers) to column 61 (total itemized deductions) in the ridiculously massive table that the the Tax Policy Center summarizes from that starts on page 137: https://www.irs.gov/pub/irs-pdf/p1304.pdf
Felt a slight shake. House was unaffected however.
I’m a programmer. All my work is ultimately, at best, useless.

That’s one of the most important lessons any good programmer learns at some point. We aren’t building monuments in software, everything we do is disposable and will eventually be someone else’s curse in the future.
Query Several LLMs at Once
That helps. I must've just missed it when it said 4.7. Most articles just state 4.7 (or 4.8) though a few are now saying "preliminary magnitude of 4.7." By the time I saw it, it said M 4.8 mwr with uncertainty ± 0.0.

Also interesting is the list of two "catalogs" with mostly similar data but very different depth reports: https://earthquake.usgs.gov/earthquakes/eventpage/us7000ma74...
> If python was able to reliably tell you possible exceptions

I know typed errors in Java are regarded by many as a failure... but it is still conceptually very appealing to me.

I love result types and pattern matching in more typed/functional languages, except that they often have similar issues to go re: not having a stack trace.
You may be getting fired soon, just fyi
That seems like the exact opposite of what he should be doing right?
Are Inline Styles Faster Than CSS?
Well, maybe I’m not cool enough to appreciate it, and maybe I’m more accustomed to the style of other languages, but if I see more than a few ifs in a file, it feels like a code smell, and it feels like some refactoring might be good. But I’m hearing that this profusion of error checking “if“ statements is the go way.

To me, the ideal in a language is to assume that everything will go right, to enunciate the core intention of the program, function, etc., and to handle errors somewhere else, maybe below the main code or something like that. Mixing it all in right there with the code, even if we end up concluding that this turns out to be the best way to deal with things, seems visually confusing to me when reading the code.
And this other personal site, with real-time multiple cursors: https://j-e-s-s-e.com
Felt it and I’m in MA. Boston area.
That's true, but it's also true than when people evaluate a problem, they tend to want to imagine the maximally scaled, most robust, "final" version thereof. And so they tend strongly to solve the wrong problem in practice, often in inappropriate languages.

Now, for the record, I happen to love Go and agree with the author about its error handling paradigms. That said, I like the python script at the top of the article a lot more still, because the problem being presented is a routine kind of thing that needs to be solved on a routine, ad-hoc basis a zillion times every day. And we don't want people writing the 80 line Go code to do that, we want them doing it in python.

Basically exception-style "I don't know what went wrong, just that it failed, let the user sort it out[1]" code is the correct solution to probably 90% of workaday problems we face. You fall through to precise error handling (and/or frameworks like in Rust that force the handling syntactically) only when you need to write code that survives in the absence of a traditional "operator". But most code doesn't run that way!

[1] In this case, the problems are likely bad filenames, bad URL, server down, etc... If your developers are running this script themselves, they'll figure that out on their own.
Either types are probably the best form of error handling.

I would agree that complaints about go's error handling are really silly because said complaints usually come from people that work in languages with exceptions where, if they choose to handle errors, need to handle them in precisely the same way as in go, just in an even more verbose form.

The only reason people coming from these languages don't like go is because go actually forces you to either deal with the error or explicitly ignore it rather than just letting your functions propagate failures, which in theory is nice but in practice leads to horrible user experience because the buck wound up not stopping anywhere up the call stack since every caller decided "someone else can handle it".
Tank go through door
I bet you’ll remember it now though :)
Show HN: Minimal Rust-inspired C++20 STL Replacement