HN user

kd5bjo

4,164 karma
Posts26
Comments1,291
View on HN
www.whitehouse.gov 2y ago

A Path Toward Secure and Measurable Software [pdf]

kd5bjo
3pts0
www.tesl-ej.org 5y ago

Polyglot: How I Learn Languages [pdf]

kd5bjo
3pts0
users.rust-lang.org 6y ago

Rust trained my sense for spotting UB in C

kd5bjo
2pts0
news.ycombinator.com 6y ago

Ask HN: What are current best security practices for custom servers?

kd5bjo
2pts6
github.com 6y ago

Show HN: I dove into Rust's FFI and Async systems over the weekend [pdf]

kd5bjo
3pts0
cognitiveresearchjournal.springeropen.com 6y ago

Face morphing attacks: Investigating detection with humans and computers

kd5bjo
1pts1
oeis.org 6y ago

The Online Encyclopedia of Integer Sequences

kd5bjo
2pts0
highscalability.com 7y ago

Justin.tv's Live Video Broadcasting Architecture (2010)

kd5bjo
250pts119
www.facebook.com 10y ago

Roomscale VR Design Notes

kd5bjo
2pts0
news.ycombinator.com 10y ago

Ask HN: What conference do you wish existed?

kd5bjo
4pts1
www.disneyresearch.com 13y ago

Computational Design of Mechanical Characters

kd5bjo
2pts0
www.facebookstories.com 13y ago

Remind HN: US Election Today - Go Vote

kd5bjo
1pts0
news.ycombinator.com 14y ago

Ask HN: How to fix intellectual property law

kd5bjo
9pts11
github.com 15y ago

Extra syntactic sugar for Objective C

kd5bjo
1pts1
www.justin.tv 15y ago

PG: Why Startups are Good at Doing Things

kd5bjo
16pts4
blog.haleret.com 15y ago

Complex Probability Calculations

kd5bjo
1pts0
blog.haleret.com 16y ago

GDC Level 1: Overview / What is a Game?

kd5bjo
1pts0
blog.haleret.com 16y ago

Ask HN: Do you want to learn about game design?

kd5bjo
22pts15
www.gamasutra.com 16y ago

No Engineer will ever be happy with a line of code that he didn't write himself.

kd5bjo
33pts29
xkcd.com 16y ago

The most common RGB monitor colors

kd5bjo
2pts0
www.ludumdare.com 16y ago

205 games written this weekend, source available

kd5bjo
3pts2
www.schlockmercenary.com 16y ago

Don’t Ask Me Where I Get My Ideas

kd5bjo
2pts0
haleret.posterous.com 16y ago

Why I won't be applying for Y Combinator

kd5bjo
9pts1
news.ycombinator.com 16y ago

Ask HN: Review my holiday project

kd5bjo
30pts34
news.ycombinator.com 16y ago

Remind HN: Election Day

kd5bjo
1pts1
gist.github.com 16y ago

Display your current git branch as part of your bash prompt

kd5bjo
32pts21

I fall somewhere in the middle these days- I really like knowing in advance that I have a place to sleep each night and that I have a way to get there, but then just do whatever I feel like in the moment for everything else.

That's also an option available to you: Mutex::new() is const, so there's no trouble putting one in a static variable. If the inner value can't be const-constructed, you'll need a way to prevent access before it's initialized; for that, you can use a OnceLock or just Box::leak() the Mutex once it's constructed and pass around a simple reference.

`Send`, `Sync`, and `Unpin` are special because they're so-called 'auto traits': The compiler automatically implements them for all compound types whose fields also implement those traits. That turns out to be a double-edged sword: The automatic implementation makes them pervasive in a way that `Clone` or `Debug` could never be, but it also means that changes which might be otherwise private can have unintended far-reaching effects.

In your case, what happens is that async code conceptually generates an `enum` with one variant per await point which contains the locals held across that point, and it's this enum that actually gets returned from the async method/block and implements the `Future` trait.

There’s no difference with a password, except that the sign-in process can be streamlined when everything works

There is one other major difference behind the scenes: With passkeys, the service you’re logging into never has enough information to authenticate as you, so leaks of the server-side credential info are almost (hopefully completely) useless to an attacker.

A quick read through of their anonymization process seems to indicate that they didn’t scan the message contents for PII (other than usernames).

If true, that seems like a huge oversight. I also wonder what would happen if someone finds their information in the dataset and requests it to be removed per GDPR or other privacy legislation.

I use Anki more as a serendipity engine than for memorization: Whenever[1] I have an interesting observation or thought, I'll write a couple of sentences about it and file two copies: One in Obsidian, with links to any adjacent/relevant notes (if any), and another in Anki as a Close deletion.

Anki is set up with a long review cycle (1 day, 1 week, 1 month, then automated) and I sit down to do my reviews about once a week. In that process, I usually end up having new ideas to make notes about based on either the randomized order the notes show up in or spotting a connection between the review note and something I've been working on lately.

[1] In practice, I let many/most of these go unrecorded - I probably average about one new note per day, but in bursts.

From my understanding, it's more that the explosion phase of a detonation is more fuel-efficient than the burning phase, but can't last very long under normal circumstances because the flame front is moving so fast-- This is a trick to continue fueling the explosion to sustain it over an indefinite time period.

Think about it in terms of an old-fashioned gunpowder line fuse: If you lay it out in a ring and have some kind of mechanism to continuously place down new gunpowder on the ring in front of the flame, you can keep it going until you run out of fuel.

This is one of the annoying constructions in English that has two common meanings which are the opposite of each other. It can either be referring to the worst possible/conceivable setback (as here) or to the worst encountered setback-- you have to use other clues like overall tone and the surrounding context to figure out which was meant.

You buy back shares and 'retire' them, thereby making everyone else's shares more valuable.

But the cash outflow to purchase those shares makes the company less valuable at the same time. In a completely efficient market, the amount of money that the company pays to buy back a share should be exactly balanced by the ownership percentage of that share, resulting in no net change to the price of the company's other shares.

I admit that I was unaware of that order, as I currently live overseas and don’t follow US news that closely.

However, the order opens with the line “By the authority vested in me as President by the Constitution and the laws of the United States of America,” and I know of no law or constitutional clause that grants the President the power to designate an official language.

I could easily be mistaken, as there are a lot of laws on the books and this isn’t my field of expertise. Usually, though, an executive order will cite the relevant authority so that everyone understands where the power comes from; this one doesn’t.

It’s also mostly symbolic, aside from rescinding a previous order— None of the executive agencies are directed to halt producing or processing non-English documents, for instance.

It's worth noting that this post is 8 years old, and some things have moved on since then.

In particular, trait object upcasting is on beta now and will be promoted to stable in a couple of weeks. I know that there has also been active development towards enabling multiple-bound trait objects, but I don't know what the status of that effort is.

The article also makes the (quite understandable) mistake of conflating a fat pointer to a trait object with the trait object itself. In Rust, trait objects are "unsized", which means they can only exist behind some kind of pointer. And any pointer in Rust that targets an unsized type grows an additional metadata field (for trait objects, a vtable pointer). This is a slightly weird behavior with a few unexpected consequences that often catches people off-guard, but understanding it is key to understanding why you can't make a trait object for something like `Clone`, which returns an instance of itself-- Because unsized types can't appear on their own, the return type of the `clone()` method would be invalid.

For a more thorough take, I recommend "A tour of `dyn Trait`" ( https://quinedot.github.io/rust-learning/dyn-trait-overview.... )

The part that troubles me is how an unenforced law is practically any different than a canceled law. In the case of the Tiktok, if the Justice Department refuses to investigate, gather evidence or file charges against Tiktok or app store owners how can any penalties be assessed against Tiktok or app stores? Collecting penalties or fines requires a court ruling and judge's order. It never gets in front of a judge without charges being filed.

If the Justice Department changes its mind (due to a change of administration or popular sentiment, for example) before the statute of limitations runs out, they can pursue a case for actions that happened during this non-enforcement period. Something being made criminal may[1] also open up new avenues of civil liability, which can be brought to court by anyone actually harmed.

[1] I don't really know how much civil and criminal law interact like this; that's a question for someone with a law degree.

US congressional districts being an order of magnitude larger than UK constituencies probably has something to do with it. Also, there are significantly more MPs than representatives, so you have to swing more legislators to your side in the UK vs the US to get your pet policies adopted.

(Sources: https://en.wikipedia.org/wiki/United_States_congressional_ap... , https://en.wikipedia.org/wiki/Constituencies_of_the_Parliame... )

The key thing that you get by integrating the two tools is the ability to more easily extract a single file from a multipart archive— Instead of having to reconstruct the entire file, you can look in the part/diskette with the index to find out which other part/diskette you need to use to get at the file you want.

There are diminishing returns but they don't really kick in until you're already pretty fit, they are only really a concern that athletes need to think about.

Unfortunately, it's people at both ends of the fitness curve that have to be careful about increased exercise frequency/intensity. On the less-fit side, the primary concern is accumulating minor injuries that reduce capacity for exercise even further leading into a downward spiral.

Striking/pressing with a shaped die is the traditional process, not least because the material itself used to be the store of value rather than the provenance of the mint— The coin shape was really there to certify how much gold/silver it contained and that the government had been paid whatever tax (seignorage) was owed on the ore.

Now that we’ve lived in a fiat-currency world for decades, it’s possible that new processes are being used as the concerns are different— anti-counterfeiting measures are more important than anti-shaving ones now, for instance.

At one point, I worked out that US dimes, quarters, and half dollars all weigh $20/lb (iirc), which made the task of counting my accumulated change a lot easier.

Back in the Justin.tv days, we used this for some messages that were passed by the client between two of our systems: The main authentication was done by the web stack which gave the client an HMAC-signed viewing authorization. That was then passed on to the video servers which knew how to check the authorization but weren’t hooked up to the main DB.

Setting things up this way meant that we didn’t need to muck about with the video server code whenever we made policy changes as well as isolating the video system from web stack failures— If the web servers or DB went down, no new viewers could start up a stream but anyone already watching could continue uninterrupted.

Because `OptionIterator` implements the `Iterator` trait, the function signature can be simplified to return just `impl Iterator<…>` like the original version did, leaving the additional type as an implementation detail.

Also, a similar solution is provided by the `either` crate [1], where the function body can return `Either::Left(std::iter::empty())` in one case and `Either::Right(…)` in the other, also hiding all of this behind an `impl Iterator<…>` return type.

[1] https://docs.rs/either/latest/either/enum.Either.html

When I was a kid, I developed a strong aversion to anything described with the terms “healthy” or “exercise” because anytime they were used, it inevitably meant that the activity had nothing else to recommend it and would be unpleasant. I think I’m finally over that particular hang-up, but it took decades.

He talks about this a bit in the final three paragraphs, that the people writing the work orders are already overwhelmed by the amount of paperwork they need to deal with, preventing them from paying enough attention to what these reports are actually saying, and these new recommendations will have the primary effect of increasing that burden.