skysight-inc/HackerNews huggingface dataset:
On mobile so no idea if this a) looks good or b) runs (especially considering the command substitutions, but you could also redirect to temp files instead), but it's just something like this:

N=0
while read -r URL; do
data="$(curl "$URL")" || { printf 'error fetching data\n' && exit 1 ; }
prop="$(jq '.data[].someProp' <<< "$data" || { printf 'error parsing JSON response\n' && exit 1 ; }
grep -v "filter" <<< "$prop" > "$N.data" || { printf 'error searching for filter text\n' && exit 1 ; }
N="$((N+1))"
done < ./links.txt

bash also has e.g. functions, so you could abstract that error handling out. Like I said, not that weird.

Edit: oh good, at least the formatting looks ok.
The military has a better model of security. They protect things at different security levels.

I've spent time in the classified world. Security can be obtained, but costs are high. At the aerospace company, we estimated for bid purposes that running a project at SECRET doubled the cost. Running at levels above that became even more expensive, and much slower. You have to partition things, so that only the really critical stuff gets the most expensive protection. It's common to have a project where the project is mostly unclassified, many things are SECRET, and a very few things are at higher levels.

The military views security as time-limited. When and where the attack will start is highly classified until the attack is underway. After that, there is no secret. New weapons systems eventually get used or cancelled, after which they're less secret. The intelligence community wants to protect info forever, though.

The credit card services get this. The CVV is required to have a higher level of protection than credit card numbers or names and addresses. Banks understand separation of functions and mutual mistrust. Most computer security work doesn't think this way.
They kinda do this. If you disable emojis, you get their text representation. It's can be misleading because the text representation sometimes diverge from what the user thinks the emoji means.
> From the "If I could" files, I would have liked to spent 5 years on an AS/400,

pub400.com still exists and probably will for 5 more years. not sure to what extent you can make it work for a company but you can at least do learning projects on it
Hmm. If one spends just 60 seconds on each, it would be a 6 month full time gig. Barely enough time to look at info/photos on Google maps and make a few quick judgement calls. Of course one could maybe reduce this of them by setting a threshold on their rating, maybe also number of reviews added last 12 months, etc.
But yeah - lots of labor to actually evaluate thousands of anything. Months possibly.
I've veen reading about graphql forever and never understood it. Your comment finally made it click for me. Do you happen to have any more documentation around your method of working?
Those things might not run bash/sh, but I’m willing to bet a hundred quid that nearly all of their development environments had at least one tiny shell script that did some transformation of data.
Unfortunately it's also hard to buy (find) people who don't know how to sell.
> The membranes repel positively or negatively charged particles, including salt molecules, bacteria, and viruses, as they flow past.

So does ICP work similar do reverse osmosis and also useful minerals calcium, magnesium are removed? Anyway it sounds like an interesting breakthrough regarding energy efficiency and portability
Microsoft laid off a DEI team, DEI is 'no longer business critical'
I am so surprised that there's no exploration of Karatsuba's algorithm. That's what makes the Python implementation perform.

I actually came here hoping to find discussion on Karatsuba.
https://en.m.wikipedia.org/wiki/Karatsuba_algorithm
Show HN: Pippy – Pipelines for GitHub Actions
I am excited to share pippy, which allows users to create configurable pipelines using Github Actions. If you have used Azure pipelines, in summary, this would be Azure Pipelines meets Github Actions.

Cloud version: https://app.pippy.dev/login (closed beta)
I am also open sourcing command line version: https://github.com/nixmade/pippy.

Key features:

- Automatic Rollback

- Datadog Monitoring

- Pause/Resume

The product is built using open source orchestrator.

Orchestrator: https://github.com/nixmade/orchestrator

Orchestrator allows you to orchestrate rollout to specific set of targets and provide monitoring capabilities to optionally rollback. I hope to provide Cloud API so platforms can orchestrate updates using the framework.

Tech stack:

Database: Postgres

Backend: Golang

Frontend: React + Shadcn UI

Cloud: Azure container apps

Please leave your feedback in comments. Hope you can give the command line version a try, and sign up for beta of the cloud version.
There is a Midori version with firefox engine. But there is radio silence about it by everybody.
There's a big problem of information asymmetry, though. "Security" is a very noisy metric, and not a quality that's easily evaluated by 99.9% of your customers. Outside of specialty domains like national defense (and even then...) customers don't generally care about "secure", they care about "not obviously insecure", and almost all products will appear to be "secure" enough right up until the moment that they're visibly or publicly compromised. If you either stay under the radar or get lucky long enough, you can turn profits for quite a while before the chickens come home to roost.
Yes, at EclipseCon 2022 an Oracle manager working on the Helidon framework presented their results replacing the Helidon core, which was based on Netty (and reactive programming) with Virtual Threads (using imperative programming). [1].

Unfortunately the slides from that presentation were not uploaded to the conference site, but this article summarizes [2] the most significant metrics. The Oracle guy claimed that by using Virtual Threads Oracle was able to implement, using imperative Java, a new engine for Helidon (called Nima) that had identical performance to the old engine based on Netty, which is (at least in Oracle's opinion) the top performing reactive HTTP engine.

The conclusion of the presentation was that based on Oracle's experience imperative code is much easier to write, read and maintain with respect to reactive code. Given the identical performance achieved with Virtual Threads, Oracle was going to abandon reactive programming in favor of imperative programming and virtual threads in all its products.

[1] https://www.eclipsecon.org/2022/sessions/helidon-nima-loom-b...

[2] https://medium.com/helidon/helidon-n%C3%ADma-helidon-on-virt...
Previously posted on Jul 12 the article "X has put most of its SF HQ up for sublease" https://news.ycombinator.com/item?id=40954195

As of then it was 70%. But maybe they didn't make it 100% last week to avoid signaling the move out-of-state.
The value function is crucial, sure. But back testing over a couple seasons I can usually land on something much better than what I as a (usually pretty casual) fan has in my head.

From an automation perspective the harder problem is getting match day squad selections (some sports regularly announce last minute teams, like at the time of the toss) and accounting for whatever special cases the game rules have tossed in (e.g. select a captain and vc, special reduced fees on trades this round, etc).

And to really win these games, rather say just beating your friends and landing top 5% globally, you also need risk management and portfolio optimisation strategies: e.g. when to play your "captain scores double this round" card? everyone has Mbappe, do you also pick him to hedge your riskier picks? I have no doubt that some players have built all this automation but I sure haven't.
> My rough understanding is that this is similar to async/await in .NET?

The biggest difference is that C# async/await code is rewritten by the compiler to be able to be async. This means that you see artifacts in the stack that weren’t there when you wrote the code.

There are no rewrites with virtual threads and the code is presented on the stack just as you write it.

They solve the same problem but in very different ways.
Previously posted on Jul 12 the article "X has put most of its SF HQ up for sublease" https://news.ycombinator.com/item?id=40954195
On a somewhat related note, I once worked on a vessel which had 'SAFETY FIRST' stencilled onto the superstructure (quite common).

Underneath, someone had stencilled in slightly smaller script 'second only to profit'

(Somewhat less common, but refreshingly honest. Or cynical. Or both)
I am generally a lover of history, but Shakespeare's comedies are just too "weird" for me. The plots that tend to rotate around some elaborate disguise etc. just cannot "roll me in".

I attended a local adaptation of the Twelfth Night a few days ago. The actors really did their best, but the plot felt like product of a brain injury to me. I wonder what has changed since the 16th century, as obviously Shakespeare's humor was genuinely popular back then.

It is a different story with the tragedies. The Merchant of Venice was very visceral even for 21st century audience. As if troubles of people (be it debt or anti-Semitism) changed less over time.
They're also useful in retro for the simple fact that something was written down. If your story point estimate was way off for a particular task, you can pull up the original conversation, identify what assumptions were violated or what new info was surfaced that wasn't present at the original estimation and whether there's learnings/process changes to be made.

Of course, retro is usually the first thing to go in a deluded attempt to increase velocity and story points hang on as this vestigial tail, contributing to more cargo cult software engineering.

edit: One scenario that might play out:

The team all agreed that tasks A, B & C were worth 3, 5 & 1 points respectively but Steve and Mei thought task D was worth 5 points but Carol thought it should be 13 because it involved integration of an external API where her experience was that other API integrations in the past had exposed hidden complexity.

Task D ultimately was not completed because during the process of integration, it was discovered that the API did support a key feature that was needed and instead, an in house alternative needed to be built.

It was decided that going forward, the team would instead assign a 1 point task to building a toy app for any new API integrations that would then feed into the process of deciding the story points for features requiring that integration.
> In cpp projects it's covering up for people that don't how to use the actually correct tool for the job: the CMake scripting language.

That’s like saying that people use lotion because they don’t know how to correctly jerk off with sandpaper.

Bash is ubiquitous and can be used everywhere, CMake scripting language can be used only in CMake, guess how many people know one better than the other?
Mapping High Level Constructs to LLVM IR
It's hard but not impossible to sell to schools. I think at my company >75% aren't working on things that impact the student experience.
> You won't find python pre-installed on all distros, like alpine

The same can be said of bash, especially since you mention Alpine (also FreeBSD)

Perl, though... ;)

(if Perl is not there it gets pulled in very quickly as a dependency of something, e.g typically you pull git, you get perl)
The point is that until we understood stellar mechanics and observed the formation of water in stellar events, we didn’t know where water originated. This suggests that we should not limit our thinking to Earth-based mechanisms when considering the formation of RNA and DNA, which are molecules orders of magnitude more complex than water.

Another problem is that the earliest fossils are 4.3 billion years old, while Earth itself is 4.6 billion years old. This means that life must have originated within the first 300 million years of Earth’s existence. What was this unique environment that enabled the creation of RNA, DNA, and cells? And why did this magical environment disappear in the subsequent 4.3 billion years?

We don't need to generate it spontaneously, but we do need to understand the mechanism precisely. Filaments alone (can you share the relevant research on this?) are not enough.

We need to understand exactly how DNA, RNA, and cells came into existence, just as we sought to understand the formation of water. Until then, we won't have the answer to the origin of life.
Glad I'm not the only one who feels that it's handwavy and full of excuses.
You think they don't know that it's blocked by the government? That's daily life, they all use vpn to access chatgpt etc.
And most humans have MUCH MUCH lower eval scores on bash, yet they write it anyway, and the rest of us get stuck with trying to use and understand and debug and maintain that crap, that bursts into fire and explosive diarrhea whenever it hits and edge condition or file name with a space in it.
I see, so bindings for gql constructs is what we’re after?
Ever since "private relay" became available on my iphone (which I don't disable even when at home), whenever I get on google maps on my PC (so not going through the private relay) google maps always shows me in random cities hundreds of miles away.

Maybe this has been useful when introduced, but I'm not convinced it still is the case.
Interestingly, those mammals that are highly resistant to cancer (such as bats or whales), tend to be resistant against all cancers at once, for decades.

Maybe a stronger immune system, such as the bats have - it is really incomparable to humans - can whack cancer cells reliably regardless of their particular genetic signature. Much like it can kill various germs without analyzing their DNA/RNA first.
Amazing game.

That rocket launcher, that grenade launcher. The suicide Bobs.
security (at least as meant in the advertisement) is also output
I am not anti reaction as such, especially when it's just a thumbs up, although I very seldom use it myself.

However I really struggle with emojis as a general concept. I don't understand a lot of them, and it seems people put a lot of hidden meaning into them that I have to interpret, and I feel the cognitive load is a lot bigger than if people would just type out what the fuck they are trying to say.
Funny, I did this myself 10 years ago. Shit, it's been that long..?

For my undergrad project I wrote a computer algebra system to do symbolic integration. The supervisor was a hardcore, old school C guy, so naturally I was going to just use C and no libraries. He told me I'd need bignums first, so I got to work (this is because many algorithms like polynomial GCD create massive numbers as they go, even if the inputs and final outputs are generally very small).

I just couldn't figure out how to do better than the largest power of 10 per digit at the time. Working with non base 10 arithmetic was a mind fuck for me at the time. So I did it with digits holding 10^9 and the classical algorithms from Knuth. Division is the hardest!

At some point I discovered the GNU multiple precision library (GMP) and made my program work with that instead of mine. I was shocked at how much faster GMP was! I finished my project with my own code, but I knew I had to come back to do it better.

The breakthrough came when I got a copy of Hacker's Delight. It has stuff like how to detect overflow after it's happened (in C). Something twigged and then I just understood how to fill each word completely rather than use a power of 10. I don't know what confused me before.

But, of course, the real way to do it is to use assembly. You can't get close to high performance in C alone. In assembly you get the overflow bit. It's actually easier in a way! So you write tiny platform specific bits for the digits and build on that in C. My add and subtract were then as fast as GMP. I lost interest when it came to implement faster multiplication algorithms.

Code in case anyone is interested: https://github.com/georgek/bignums
It is ironic that those who are less well off fail to see any connection between those they vote for and their personal interest. Those who least need to benefit do see it.
As a linux admin, bash and python are my bread and butter.
I have two heuristics for choosing between them:
- If it needs more math than counting, choose Python
- If it's >200 lines (500 if I'm brave), choose Python

Otherwise, shell scripting is nice
When whimsical wildlife photography isn't what it seems
Handy resource. Thanks.

Is see IFF is missing from that list. Used to be popular in the Amiga world https://en.wikipedia.org/wiki/Interchange_File_Format
Oh, this is so great - thanks for sharing, I'm going to dive deep into this crazy, weird, Postscript rabbit hole ..

(Been reading POC||GTFO for years, but now I finally think its time to write something..)
What's most exciting to me is the amazing dev tools they may create..
I don't understand this renewable vs. nuclear rhetoric, when the comparison should be made with clean vs. fossil sources.

But as always humanity manages to get lost in a glass of water.
ClearRx
> To put it shortly: Writing single-threaded blocking code is far easier for most people. [snip] With virtual threads that problem is eliminated so we can go back to writing blocking code.

This is the core misunderstanding/dishonesty behind the Loom/Virtual Threads hype. Single-threaded blocking code is easy, yes. But that ease comes from being single-threaded, not from not having to await a few Futures.

But Loom doesn't magically solve the threading problem. It hides the Futures, but that just means that you're now writing a multi-threaded program, without the guardrails that modern Future-aware APIs provide. It's the worst of all worlds. It's the scenario that gave multi-threading such a bad reputation for inscrutable failures in the first place.
>Everyone who believes in it agrees it works, but not how it works? That's a classic sign of witchcraft.

No, its a sign of incomplete scientific investigations. Or are you going to tell me everyone knows how SRRI's work, to take the most overt example of incomplete sciencey/witchcraft?

(We don't know how they work, just that they do work, so hey .. ship the pills, witches ..)
The future is inference. Many inference stacks already support AMD although the kernels are less optimized. This will of course change over time, but if AMD can crack the inference demand, it will put NVDA under huge pressure.
nowhere capable of solving them, but my understanding is that we still have a sea of unchartered territories when it comes to research here. but it has become apparent now more than ever that what seems alien or niche today might become seminal in the future.

long story short - we just need the link between theory and real life. you will find plenty problems, interesting even (at least for someone).
No, I need a diagramming tool. Excalidraw lives on
Around the mid 80s, for example the 386 was the first x86 processor to largely use standard cells.

It seems appropriate to cite Ken's blog post on the topic: https://www.righto.com/2024/01/intel-386-standard-cells.html
So the intentions are part of the dowsing process, and the science has not caught up with that yet.
Are those really the same?

- "commodity exports" -> "raw materials"?

- "hard currency" -> "foreign currency"?
In an outlook only company, reactions make a ton of sense. They save tons of "great, thank you " emails.

Of course you can still send real thank you emails when you're genuinely thankful!
You will still have to worry, too many virtual threads will imply too much context switching. However, virtual threads will be always interruptable on I/O, as they are not mapped to actual o.s. threads, but rather simulated by the JVM which will executed a number of instructions for each virtual thread.

This gives the chance to the JVM to use real threads more efficiently, avoiding that threads remain unused while waiting on I/O (e.g. a response from a stream). As soon as the JVM detects that a physical thread is blocked on I/O, a semaphore, a lock or anything, it will reallocate that physical thread to running a new virtual thread. This will reduce latency, context switch time (the switching is done by the JVM that already globally manages the memory of the Java process in its heap) and will avoid or at least largely reduce the chance that a real thread remains allocated but idle as it's blocked on I/O or something else.
> where someone spoofs an Apple device requesting network creds

How does this work? Isn't there any verification done through iCloud or something? I don't expect my phone to know about all my contacts' iphone identifiers.

I just tried this the other day with my cousin's wife whose phone number I don't have stored in my contacts and it didn't offer to share the wifi password until we both added each other's number.
> Both MS-DOS and CP/M still had the very clear and almost identical concept of a "file" in the first place.

ms-dos files (after 2.0) were sequences of bytes; cp/m's were sequences of 128-byte 'records', which is why old text files pad out to a multiple of 128 bytes with ^z characters. ms-dos (after 2.0) supported using the same 'file' system calls to read and write bytestream devices like paper tape readers and the console; cp/m had special system calls to read and write those (though pip did have special-case device names). see https://www.seasip.info/Cpm/bdos.html

that is, this

> CP/M (...) instead see[s] "files" as a stream of bytes/words/octets or whatever.

is not correct; cp/m has no system calls for reading or writing bytes or words to or from a file. nor octets, which is french for what ms-dos and cp/m call 'bytes'

admittedly filesystems with more than two types of files (ms-dos 2+ has two: directories and regular files) are more different from cp/m
Anki contributor here:

I’ve been using SRS on and off since 2006 and this post addresses one of the key failure modes I’ve seen in SRS usage—they tend to be fantastic for discrete pieces of information, like the names of capital cities, the pronunciation of various symbols or various physical constants.

Most my usage of SRS in the early days was languages. For that domain, SRS is useful for learning an alphabet (or syllabary), for scaffolding enough common words to start understanding graded readers and for a few other tasks.
They’re terrible as a primary learning strategy, though! Too much of language is highly nuanced and context dependent and the only way to absorb all the unwritten rules, the common collocations and the precise boundaries of word meanings is through extensive input. This means encountering the same words and structures in countless different variations and contexts, not the same few sentences drilled repeatedly (at least past the beginning stages).

By paying attention to the specifics of learning math and tailoring the SRS to match it, it’s possible to make a far more efficient system than anyone could with an Anki deck. I’d love to see similar efforts in other subjects!
I'm reading about this man but really struggling to understand what his philosophy is, or what he actually did it said that was racist. I feel like everyone is beating around the bush.

That said, my concern is that the label 'radicalization', itself, will be weaponized. Some things are inflammatory. That doesnt mean they should be censored.

George Floyd being murdered certainly radicalized people. As a result we had riots and even killings. But I certainly don't want BLM advocates shut down for radicalizing people.
Seiko Had a Smartwatch in 1984