DevelopingElk

il y a 2 moisdiscuss

CPS is a way of embedding imperative computation into an FP language. I think they built a mini compiler for their binary relation language, which is then Jitted by Julia.

DevelopingElk

il y a 2 moisdiscuss

Russian one time pads were frequently broken. How? They were inconvenient to distribute, so people reused them.

Symmetric cryptography is safer because one key can easily protect as much data as you need.

DevelopingElk

il y a 3 moisdiscuss

One of the data center's cooling loops broke.

DevelopingElk

il y a 3 moisdiscuss

I ran into this problem where I wanted to generate balanced trees for test cases, and I decided to crack it with math.

Let X = the number of remaining open parenthesis required to reach your target length, and Y = the number of remaining close parenthesis.

Let P(X) = X/(X+Y) * (1 + 1/(Y-X+1)). Generate an open parenthesis with probability P(X), and otherwise a close parenthesis.

This will efficiently generate an unbiased random plane tree. The reason this works has to do with counting the valid ways to complete the plane tree, using a calculation similar to the one in the article.

DevelopingElk

il y a 3 moisdiscuss

His claim is that we exp-minus-log cannot compute the root of an arbitrary quintic. If you consider the root of an arbitrary quintic "elementary" the exp-minus-log can't represent all elementary functions.

I think it really comes down to what set of functions you are calling "elementary".

DevelopingElk

il y a 4 moisdiscuss

According to the article “This work effectively rules out explanations of the Hubble tension that rely on a single overlooked error in local distance measurements". So any systemic errors would need to affect multiple measurement types.

DevelopingElk

il y a 4 moisdiscuss

Good? Bad? Doesn't matter as long as you had fun.

Have you tested this GCs performance? Sometimes a baby GC can be fast enough.

DevelopingElk

il y a 4 moisdiscuss

The issue with Regex for parsing is it can't handle balanced parentheses. https://en.wikipedia.org/wiki/Regular_expression. More generally, they can't handle nested structure. Context free grammars are the most natural extension that can. It adds a substitution operator to Regex that makes it powerful enough to recognize nested structure. So, Regex would be reinvented if history was rerun, but so would Context Free Grammars. Part of the complexity in parsing is attaching semantic meaning to the parse. Regex mostly avoids this by not caring how a string matches, just if it matches or not.

Now, I do agree that LR grammars are messy. Nowadays, they have mostly fallen from favor. Instead, people use simpler parsers that work for the restricted grammars actual programming languages have.

IIRC there is some research into formalizing the type of unambiguous grammar that always uses () or [] as nesting elements, but can use Regex for lexing.

DevelopingElk

il y a 5 moisdiscuss

I'm fairly sure this was human written.

DevelopingElk

il y a 5 moisdiscuss

Rust's discussion boards has an idea of "keyword generics" for expressing some of these concepts. The idea is that a function can be generic over const, async or some other keyworded effect. I like this description. It shows the benefits without too much theory.

DevelopingElk

il y a 5 moisdiscuss

Yours might go a little less into the details, but its really clear and I like the diagrams and explanation around glitch hazards. Please do follow up on your tangents if you have time.

DevelopingElk

il y a 5 moisdiscuss

I have commented once or twice on articles being AI generated. I don't put them when I think the writer used AI to clean up some text. I added them when there are paragraphs of meaningless or incorrect content.

Formats, name collisions or back-button breakage are tangential to the content of the article. Being AI generated isn't. And it does add to the overall HN conversation by making it easier to focus on meaningful content and not AI generated text.

Basically, if the writer didn't do a good job checking and understanding the content we shouldn't bother to either.

DevelopingElk

il y a 5 moisdiscuss

This is written by an LLM account. My guess is this article was created with some human guidance too, but the profile shows LLM patterns.

DevelopingElk

il y a 5 moisdiscuss

The start of the article is good, but it starts to sound like LLM staring at the "Why this maps to Genetic Algorithms?" section. Is that the case?

DevelopingElk

il y a 5 moisdiscuss

By the definition of a cryptographically secure PRNG, no. They, with overwhelming probability, produce results indistinguishable from truly random numbers no matter what procedure you use to tell them apart.

DevelopingElk

il y a 6 moisdiscuss

I worked on a team deploying a service to European Sovereign Cloud (ESC). Disclaimer - I am a low level SDE and all opinions are my own.

AWS has set up proper boundaries between ESC and global AWS. Since I'm based out of the US I can't see anything going on in ECS even in the service we develop. To fix an issue there we have to play telephone with an engineer in ESC where they give us a summary of the issue or debug it on their own. All data is really 100% staying within ESC.

My guess is that ESC will be less reliable than other regions, at least for about a year. The isolation really slows down debugging issues. Problems that would be fixed in a day or two can take a month. The engineers in ESC don't have the same level of knowledge about systems as the teams owning them. The teething issues will eventually resolve, but new features will be delayed within the region.

DevelopingElk

il y a 8 moisdiscuss

The consequence of Noether's theorem is that if a system is time symmetric then energy is conserved. On a global perspective, the universe isn't time symmetric. It has a beginning and an expansion through time. This isn't reversible so energy isn't conserved.

DevelopingElk

il y a 8 moisdiscuss

RL before LLMs can very much learn new behaviors. Take a look at AlphaGo for that. It can also learn to drive in simulated environments. RL in LLMs is not learning the same way, so it can't create it's own behaviors.

DevelopingElk

il y a 9 moisdiscuss

Oof, I think that you are right. The issue with Futurelock is a failure of liveness, where the Future holding the lock doesn't get polled. tokio::join! would keep it alive and therefore my suggestion would mistakenly panic.

Yeah, the true fix is probably some form of the fabled Linear types/Structured concurrency where you can guarantee liveness properties.

DevelopingElk

il y a 9 moisdiscuss

Disclaimer - I'm not a Tokio dev so what I say may be very wrong. Some definitions:

    Future = a structure with a method poll(self: Pin<&mut Self>, ...) -> Poll<Self::Output>; Futures are often composed of other futures and need to poll them. 


    Tokio task = A top-level future that is driven by the Tokio runtime. These are the only futures that will be run even if not polled.

My understanding is that Tokio async locks have a queue of tasks waiting on lock. When a lock is unlocked, the runtime polls the task at the front of the queue. Futurelock happens when the task locks the lock, then attempts to lock it a second time. This can happen when a sub-future of the top level task already has the lock, then it polls a different future which tries to take the lock.

This situation should be detectable because Tokio tracks which task is holding an async lock. One improvement could be to panic when this deadlock is spotted. This would at least make the issue easier to debug.

But yes, I think you are right in that the async mutex would need to take the future by value if it has the capability of polling it.

comments