skysight-inc/HackerNews huggingface dataset:
It doesn't help me to know that i do unique contribution by just existing.

The existence in itself needs a reason.
Someone else already posted a comment with the exact file.
Time to examine the anatomy of the British Library ransomware nightmare
I absolutely love Jacaranda trees, and I find myself saying the word a few times a day. Better at a distance though.
The violation happened in 2021. https://ico.org.uk/about-the-ico/media-centre/news-and-blogs...

I'm actually surprised the ICO can fine the UK government. This can't happen in France, for instance.
Context switching cost is mostly artificial. You save kernel/user transitions, but you can also have user-mode threads without transitions. What else are you saving by using coroutines instead of threads? You're not saving register swapping or cache warmup. You are saving stack allocations but those don't cost time.
I don't find the initial Cleartype algorithm used by Windows to be exactly good either. You could tell from miles away that it's distorting fonts significantly in order to fit them into the pixel matrix. I think they've improved it for Windows 10/11 though.
The point he's making is that software engineering skills are about a lot more than just programming. Being able to navigate an existing codebase, implement new functionality and blend it into the surroundings is an important skillset that is pretty distinct to just writing code.
who made this requirement? in which country?
An interesting fact: a 1D random walk will almost always return to the origin (as in, given an infinite number of runs, only finitely many will not return to the origin), wheras a 2D random walk will almost never return to the origin (of an infinite number of runs, only finitely many will return to the origin). Of course, this is directly saying much about the average distance from the origin, which slowly increases with steps as mentioned by others.
The article does mention you get a computer with all that set up already.
There's always some uncertainty to any kind of answer or computation, it's just at some threshold we unconsciously decide to take it for a fact.
There's no Eureka moment required. "Add a feature similar to an existing feature to a codebase you don't know yet" is what people often do during their usual day. It's a good test of quick exploration, being ok with uncertainty, and coding. If that's what the company is after - great.
You can take a look at https://wiki.trinitydesktop.org/Icon_Sets But note that most of these icon sets will scale quite badly to modern HiDPI resolutions. (Though you could scale them manually using Lanczos upscaling, which usually gives a nice 'watercolor' effect preserving the broad look of pixel art.)
For anything related to CUDA/CuDNN, use one of NVIDIA base Docker images. Then whether you use Conda / Pip / Poetry / Pipenv does not matter much. Not at all a Conda fan myself and avoid it like the plague
Thirty years ago I started a wine-tasting group with the person who is now my wife. There were twelve of us, and one day we did a blind tasting of six California cabs, with Barefoot on the low end ($3/bottle at the time) and Silver Oak at the high end ($50). Everyone in the room ranked the Barefoot first or second, and everyone ranked the Silver Oak dead last. That experience knocked the wine snobbery out of me for good.

It's possible we just got a bad bottle, but I don't think so. I think a dry full-bodied wine is just an acquired taste which none of us had yet acquired. Thirty years on I like Silver Oak better than I did then, but I can list a dozen wines I like better that cost half as much.

There is no such thing as a good wine in any absolute sense except in a few very broad brushstrokes. Beyond that it's all a matter of personal taste.
How about prefix then?
https://prefix.dev/blog/uv_in_pixi
Indeed, I went through a very similar philosophical dilemma as well. I eventually decided that the convenience outweighed the security reduction, in part because the security reduction feels fairly minimal as they still live only on local devices and not on a device accessible to anyone besides me.

I still can't bring myself to put them into bitwarden, though. I suspect that will be a line I refuse to cross for quite some time, even though the convenience and luxury of doing so is tempting. Having my seeds in the cloud to me definitely reduces a factor
Volvo B18 Engine
I think there’s a third source, which is that it gets you drunk. We like to pretend it doesn’t, and that we can hold our alcohol or that were supposed to spit it out when doing a tasting, but let's be real. Alcohol does a number on your senses and thought patterns, and any conclusions drawn from subjective experiences while intoxicated are automatically suspect.
They can balance but still be random -- that's the essence of drawing without replacement, or the hypergeometric distribution.

What you probably mean is that they are no longer independent.
AMD's secret sauce is a smart cache using like a 1 or 2 layer NN or something.
We see NVIDIA's major insight long ago, to but generic compute cores on their chip (so as to no longer need to predict how many shader units, how many geometry units, etc, just have a pool of generic units)

So it follows that intel is doing something similar i.e. NN type units which may be used for ML, where the cache is not so important, or in your typical non-ML settings such as gaming or web browsing, these NN units will reduce cache misses at an incredible rate and thus (effectively) up memory i/o rates by 400-500%
Are you seriously trying to suggest medical charities and trusts should be exempt from client data protection?

The only 'culture war' here is the one you are introducing.
The "crazy subscription fees" are about $40 more than the $80/month I pay for pretty modest Internet. Not everyone has great cellular service. I barely get it 50 miles west of Boston--presumably because I live at the base of a hill between myself and the tower. I routinely lose cell entirely when I take the train in through some of the highest-end suburbs in the area.

Starlink really is a game-changer for people who don't have other good Internet options. And there are a lot of them even if they don't live on a montaintop in Wyoming someplace. Can everyone in rural locations afford broadband at all? No. But Starlink is actually pretty competitive with equivalent broadband offerings.

I am a long way from being a Musk fanboy but Starlink is genuinely extremely useful for a lot of people.
I am pretty sure there would be new dimensions to sexual behavior, details depending on the motor control we'd have.
Yes. I simply do

python -m pip install torch torchvision

and it works. It used to not, but it's been fine for me for about a year now.

There's a very good chance I've installed cuda on my system before this though. And usually cudnn and some other packages because this is part of my standard install. And then I also never run into the issue where a package is looking for nvcc.
> If I were interviewing you and you were not referred (referrals might be able forego assessments) and if you refused to do this, I would feel that your attitude was a bit unreasonable and it would make me think less of you as a candidate.

Don't worry, I would withdraw my application.

> But really it’s a willing buyer willing seller scenario

Yeah and my point is that I'm the seller and so should be every other candidate.
Do any lisps support the interactive style of programming CL is famed for, apart from CL itself? I think resumable exceptions are an important part of it.
Further, perhaps quite a lot of marketing is certainly exaggerated and I wonder how wine gets singled out. Think about how feminine hygiene products are marketed with frolicking white-dressed women, or cars tearing across the landscape, Apple tech, sports drinks, fashion. Here are some phrases from just one particular hiking shoe!

Mud Contragrip® outsole with chevron lugs
EnergyCell midsole
Moulded Ortholite sockliner
Sensifit™ system cradles the foot
Advanced Chassis insert

!
Implementation difference. Threads are usually handled by the kernel and each one has its own stack where you can put anything. And the kernel can switch threads at any time. Async/await has the compiler work out precisely what has to be saved across the marked locations which are the only places context switches can happen. Also it doesn't tell the kernel when it switches context.
Yeah, I suspect a lot more people have experienced diarrhea than appendicitis. If preserving gut bacteria is important enough, then the appendix clearly does have a function.

But it might not be that important at all; do people with an appendectomy struggle more to recover from diarrhea?
I'm pretty sure this is a problem relating to tokenization. There are hardly any tokens that can be used for reversing text.

I simply took the "interesting fact" and added this to the prompt: "Reverse the sentence. Here is the beginning: ".noitatipicerp laminim seviecer"

Here is the result I got:

".noitatipicerp laminim seviecer" (prompt) - "taht ecalp a sa treseted a fo noitinifed eht yb htraE no treseted tsegral eht sa ti seifilaqulc esnapxe tsa v s'acitr nA.serutarepmet gnizeerf sti etipseD.dnali ni sse l ne ve na d t so ac eht g n o l l a ff all wons ) mc 5 . 61( seh cni . 5 6 tuoba fo noitatipicerp launn a egareva htiw, noitatipicerp eltt i l y r e v s eveice r ti esuaceb treseted a sa deifissalc si acitr an t A. e cap s d n a l y ci sti ot eu d dekool revo net fo tneu qer itnA" .a n fe ts erita n o t se r tse degral s'd lro w e ht taht stcaf gnitanicsaf enO".

Manually reversed back into original order:

"One fascinating facts that th e w orl d's larged est r es t o n atire st ef n a. Anti req uent of ten over looked d ue to its ic y l a n d s pac e .A t na rtica is classified as a detesert because it r ecieve s v e r y l i ttle precipitation ,with average a nnual precipitation of about 6 5 . inc hes (16 . 5 cm ) snow lla ff a l l o n g the ca os t d an ev en l ess in iland.Despite its freezing temperatures.An rtica's v ast expanse cluqalifies it as the largest detesert on Earth by the definition of a detesert as a place that" - (prompt) "receives minimal precipitation."
Human beings do arithmetic problems wrong all the time so I'm not sure "doing addition 100% right" is a merit of intelligence.

I'm not saying LLM will achieve AGI (I don't know if it will, or when it does we'll even know). But somehow people seem to be judging AI's intelligence with this simple procedural:

1. Find a task that AI can't do perfectly.
2. Gotcha! AI isn't intelligent.

It just makes me question humans' intelligence if anything.
What uncertainty and threshold is there in the addition of integers, for example (within mathematics and the usual definitions)? Or in Boolean logic with the "and" operation?

I don't think everything has uncertainty and thresholds to it, especially, when it actually resides outside of a technical implementation.
There is nothing more permanent than the temporary.

There is nothing more temporary than the permanent.

At least that's what the Russians say.
> Did you ever see Mark Ferrari's animated pixel art landscapes from the 1990s?

I have seen these long ago, thanks a ton for the working link.

Considering it is not some modern trendy pixel dithering, I can hardly imagine the amount of work required to create this art back then.
Steam tags are often questionable.

I'd consider a city builder to actually... Build a city.

Against the storm is more of a strategy game, with caveat that your strategy needs to center around the pure chance RNG for what building you're allowed to unlock.
I think the question is, why don't other fields put this huge emphasis on the fear of bullshitters and frauds?

My take: There's some extreme sampling bias at play. Everyone knows at least one horror story where someone managed to bullshit their way to a position. Now they imagine that this must be a problem, while ignoring the vast majority of devs they've worked with that were legitimate developers.

The field of software engineering is also much more personal and opinionated than traditional engineering. This lowers the threshold for what devs. will classify as "frauds" - not because the people they accuse might actually be frauds, but because they are not up to their standards.
I have no doubt that it's possible to design an algorithm that can produce diagrams in a given style, given a sufficient description. But a GPT is only going to learn that sort of thing via sufficiently-many examples.

This problem is fundamentally different to (e.g.) computer chess, in that we have no algorithmic win condition. You can't brute-force a solution space when your only way of assessing whether candidates are any good is to ask a human. (Especially not when humans use heuristics to assess the quality of something at a glance, and find it tiring to process large quantities of data: that's a simple recipe for specification gaming if ever I saw one.)
Details at https://ico.org.uk/about-the-ico/media-centre/news-and-blogs...

That was an error with potentially very grave consequences, but it seems the MoD handled it well once they were aware of it (“Soon after the data breach, the MoD contacted the people affected asking them to delete the email, change their email address, and inform the ARAP team of their new contact details via a secure form. The MoD also conducted an internal investigation, made a statement in Parliament about the data breach, and updated the ARAP’s email policies and processes, including implementing a ‘second pair of eyes’ policy for the ARAP team when sending emails to multiple external recipients”)

I don’t think a larger fine would have made them do better, so why make it higher?
legal consent in GDPR needs to be understandable, can not be hidden in any way, and easy to remove.

The common lawyer's hack of hiding it in a big long unreadable contract won't cut it, and should lead to fines.

Everybody talks crap about the GDPR, but as someone who, while not a lawyer, has worked on technical laws and standardization, I gotta say they really did a great job on not letting any companies have an easy out.
Random walks have plenty of counter-intuitive properties when it comes to returning to the origin.

- The average distance from the origin increases as time goes on.

- But the average coordinate any given step ends up on is and remains the origin for the duration of the walk.

More weirdly, though I don't know if this is true in two dimensions (ah, a sibling comment states it only holds in one dimension -- thanks!)

- As time goes on, a single random walk will take longer and longer to return to the origin.

- But a single random walk still returns to the origin infinitely often!
"makes certain syscalls" is a highly unconventional definition of "blocking" that excludes functions that spin wait until they can pop a message from a queue.

If your upcoming systems language uses a capabilities system to prevent the user from inadvertently doing things that may block for a long time like calling open(2) or accessing any memory that is not statically proven to not cause a page fault, I look forward to using it. I hope that these capabilities are designed so that the resulting code is more composable than Rust code. For example it would be nice to be able to use the Reader trait with implementations that source their bytes in various different ways, just as you cannot in Rust.
There is a preprint linked on the sister comment
> Positively surprised to see that fines are being enforced for non-compliers

Why? I'm curious what it was you expected to happen?
This is a really common comment to see on HN threads about async/await vs fibers/virtual threads.

What you're asking for is performance to be represented statically in the type system. "Blocking" is not a useful concept for this. As avodonosov is pointing out, nothing stops a syscall being incredibly fast and for a regular function that doesn't talk to the kernel at all being incredibly slow. The former won't matter for UI responsiveness, the latter will.

This isn't a theoretical concern. Historically a slow class of functions involved reading/writing to the file system, but in some cases now you'll find that doing so is basically free and you'll struggle to keep the storage device saturated without a lot of work on multi-threading. Fast NVMe SSDs like found in enterprise storage products or MacBooks are a good example of this.

There are no languages that reify performance in the type system, partly because it would mean that optimizing a function might break the callers, which doesn't make sense, and partly because the performance of a function can vary wildly depending on the parameters it's given.

Async/await is therefore basically a giant hack and confuses people about performance. It also makes maintenance difficult. If you start with a function that isn't async and suddenly realize that you need to read something from disk during its execution, even if it only happens sometimes or when the user passes in a specific option, you are forced by the runtime to mark the function async which is then viral throughout the codebase, making it a breaking change - and for what? The performance impact of reading the file could easily be lost in the noise on modern hardware and operating systems.

The right way to handle this is the Java approach (by pron, who is posting in this thread). You give the developer threads and make it cheap to have lots of them. Now break down tasks into these cheap threads and let the runtime/OS figure out if it's profitable to release the thread stack or not. They're the best placed to do it because it's a totally dynamic decision that can vary on a case-by-case basis.
Maybe, but project dragonfly didn’t get known to the public because those employees were underpaid.
Yes, very much agree. I am uncomfortable with the idea of putting them into a cloud service such as bitwarden, not because of a distrust for bitwarden, but rather having them on the cloud and/or in the same place as the passwords feels like big reduction in security. Simply having them on an additional local device does not feel like much of a change to me.

To each their own though, and everyone has a different level of risk, and a different level of risk tolerance. With all security, it comes down to an evaluation of that. I know some people in a very safe area who don't even lock their car or their house. They have not had any issues, and it can be very convenient not to have locks. That security posture is not for me, but it works for them.
If your CTO will say: next quarter we will start to record and sell user's data. Will you start working on the implementation or sign the resignation letter?
That wouldn't apply. But if you bought a GM car while in the U.S and imported it to Europe GM better have thought of that eventuality.
I'm really interested in the topics discussed in this article. My new Haskell effect system, Bluefin[1], is based on this idea of "contexts" (which Bluefin calls "handles"). Bluefin explicitly passes handles. There's another effect system called effectful[2] which does the implicit version. I prefer the implicit version and disagree with the claim in the article that it will lead to dozens of arguments. What we normally do when we have dozens of things that belong together is that we package them all up into data structures/records/objects that group related functionality. I expect that approach to be applicable to passing contexts too.

[1] https://hackage.haskell.org/package/bluefin

[2] https://hackage.haskell.org/package/effectful
I don't think so. Their hardware was the better thing.

What they should have done is cannibalise themselves. Something extremely difficult, but it could be done.

Fairchild did that with the integrated circuit. There was a coup inside from the people that wanted to kill the IC and stay selling expensive in small quantities instead of going to earning way less per unit en masse.
Homebrew really bugs me. The devs want you to use the most current version of Python. Except the requirement is set at the package level and there's no enforcement. So you just keep getting python versions installed.

I don't get why you just don't set a minimum version like every other manager. Or if you want to do this crazy thing, don't rely on package maintainers to enforce it. I just ends up in major bloat
>Cygwin

The author uses MSYS2 which is based on Cygwin: https://www.google.com/search?q=msys2+based+on+cygwin

EDIT add : >I wonder why that is not an option anymore.

In the particular context of the blog, the author deliberately wants to make MSYS2 the main environment when he wrote: "These prerequisites are not just to use mutt, but to use msys2 successfully in any capacity for development or other work."

Therefore, installing Cygwin separately for Mutt would work but it contradicts the goal of him wanting to use MSYS2.
Whilst I agree that this is an annoyance and can form bad habits in users (as another comment pointed out), in modern macOS systems, what you’re actually being asked for is the credentials of the “volume owner” to perform a change to the sealed system volume. This is indicated in the dialog, but agree that it could be clearer and less jarring.
I thought the recommended approach these days was to use the venv package built in to python3 with `python3 -mvenv ...`
Google Maps satellite view: https://maps.app.goo.gl/hfQpWZVQRj22Avsd6

You can really see the flatlands around them and why they'd be a refuge in times of flooding.
In that case you could use gnome-drive or whatever it's called, it's all point and click!
it's a priority, a really low priority but still prioritized.
Yeah, Microsoft looked at callback hell, realized that they had seen this one before, dipped into the design docs for F# and lifted out the syntactic sugar of monads. And it worked fine. But really, async/await is literally callbacks. The keyword await just wraps the rest of the function in a lambda and stuffs it in a callback. It's fully just syntactic sugar. It's a great way of simplifying how callback hell is written, but it's still callback hell in the end. Where having everything run in callbacks makes sense, it makes sense. Where it doesn't it doesn't. At some point you will start using threads, because your use case calls for threads instead of callbacks.
Looks like pretty classic American architecture to me. It just needs some turrets and dormers.
You're probably better off with a recursive wget here. IIRC redmine was not really javascript heavy and monolith looks to me like it only saves one page.
Ask HN: What are actual uses for blockchain that are NOT possible without it?
Spotify tests video courses to teach everything from music production to excel
I am really loving these 'new' pure rust tools that are super fast and efficient, with lovely API/doco. Ah, it feels like the 90s again... Minus 50% bugs probably.
This might just be me but I'm surprised how many icons are quite confusing in that certain icons either look very similar to another one (a lot if them literally are just glued together) or shares similar colors.

It's probably one thing I actually like more about the XP or Linux (KDE) iconset.
> So while you _do_ have to serialize access to shared IO resources, you do _not_ have to serialize access to memory(just add the connection to the hashset, no locks).

No, this can still be required. Nothing stops a developer setting up a partially completed data structure and then suspending in the middle, allowing arbitrary re-entrancy that will then see the half-finished change exposed in the heap.

This sort of bug is especially nasty exactly because developers often think it can't happen and don't plan ahead for it. Then one day someone comes along and decides they need to do an async call in the middle of code that was previously entirely synchronous, adds it and suddenly you've lost data integrity guarantees without realizing it. Race conditions appear and devs don't understand it because they've been taught that it can't happen if you don't have threads!