Genbox

Agner's table[1] for Intel IceLake/TigerLake shows FDIV to have higher latency, but slightly better throughput.

For latency:

- DIV/IDIV r32: 12 cycles

- DIV/IDIV r64: 15 cycles

- FDIV: 14–16 cycles

Throughput:

- DIV/IDIV r32: 6 cycles

- DIV/IDIV r64: 10 cycles

- FDIV: 4–5 cycles

I didn't check for a more recent CPU.

[1] https://www.agner.org/optimize/instruction_tables.pdf page 366 & 369

Publishing a zero knowledge proof rather than the solution is pretty clever.

If I would like to build a visualization like this, but for a data ingestion pipeline, any tips on where to start?

I have it visually in my head, but it feels overwhelming getting it into a website.

PHP loads all available functions into a giant hashset (see zend_disable_function in PHP's source). 'disable_functions' removes the functions from the hashset, making them unavailable to be called. Due to its interpreted nature, this indirection works much like a sandbox would.

Are you saying that two weak factors are more secure than one strong factor?

That is also a Windows 10 feature

I agree with this. As someone who took 3 degrees in computer science, one called "systems developer" and another called "software engineer", I can confidently say we have a taxonomy problem in computer science education.

It makes me crazy that companies labels there entire programmer workforce as "software engineers" when there are no engineering concepts involved at all. Other fields (medical, mechanical, civil engineering) are a lot more mature in this area and have solved this issue long ago.

Thanks!

The direct hooking into the narrow phase solver is the most performant way to go about it, but it does present several issues in state management. I did the same thing in Farseer Physics Engine, but also added high level events on bodies[1]. The extra abstraction makes it easier to work with, but due to the nature of delegates in C#, it was also quite a bit slower.

They could do with creating defaults for the narrow phase handler, buffer pool, threat dispatcher, etc. for devs who don't need extreme performance and just want a simple simulation.

[1] https://github.com/Genbox/VelcroPhysics/blob/ddf8292da6bc59e...

Wow. That is actually very impressive. Things have moved quite a lot since I did a physics engine.

What makes it difficult to integrate?

That's a bit disingenuous. Can you substantiate your claims?

The security of the Apple ecosystem is miles ahead of others. Every time I reverse engineer some component of their OS, it is very different from what I've seen before. I always find myself surprised by their thoughtfulness and engineering craft.

Recently I've taken on their code signing component. The concepts they've created, such as identifying applications by their "designated requirements" is a stroke of genius. It makes the system completely stateless and capable of almost anything without auxiliary data structure or additional code.

I've seen other engineering teams try and fail at building something similar, and never with such powerful simplicity.

The condition is called Anosmia and can stem from different sensor and brain conditions. It would be interesting to try the technique on people with these conditions to map the different kinds of olfactory failures.

If you get in contact with the researchers, please let us know how it went.

It is also kinda a self-burn. Chromium an aging code base [1]. It is written in a memory unsafe language (C++), calls hundreds of outdated & vulnerable libraries [2] and has hundreds of high severity vulnerabilities [3].

People in glass houses shouldn't throw stones.

[1] https://github.com/chromium/chromium/commits/main/?after=c5a...

[2] https://github.com/chromium/chromium/blob/main/DEPS

[3] https://www.cvedetails.com/product/15031/Google-Chrome.html?...

This is related to a technical deep dive released a few weeks ago: https://github.com/Zephkek/Asus-ROG-Aml-Deep-Dive?tab=readme...

HN post: https://news.ycombinator.com/item?id=45271484

I generally agree. However, there are several important optimizations that Roslyn does not yet have. I love the improvements in newer versions of the compiler as much as the next guy, but historically, waiting 20 years on getting basic inlining, hoisting and SIMD accelerations has left many of us with the only option of not relying on C# for performance.

Taking a bunch of data from the Korean National Health Insurance database and looking for one specific connection is less than helpful. Like carl sagan said: extraordinary claims require extraordinary evidence.

A significant error I often see in cancer studies, is the assumption that after a carcinogenic event (consumption of something toxic, exposure to radiation, etc.) suddenly there is a tumor of such a large size the person notices it and gets it investigated by a medical professional.

Some cancers take years to grow, which means the increase in certain cancer-type rates cannot possibly be explained by a carcinogenic event within a 1-year timescale.

Science is not just about finding relationships in data. You have to justify the claims, argue against them, uncover biases and guarantee the correctness of data. Statistical links are the weakest form of evidence and literally anything can be proven if not graduated through the scientific model.

It looks like a process model; isolation between programs with a system for inter-process communication, and running within a single process's memory.

If I understand correctly, instead of writing a c++ application to offload the computation of something, and then build a way of communicating the result between processes, you create a Space, define it as JIT/AOT, managed/unmanaged and execute it and use the built-in communication for transfering data.

It is an interesting approach. The author should check out Unity's Burst compiler. It takes a chunk of C# code, AOT compile it with LLVM and then the main application can invoke it. The concepts are adjacent.

I ported BinaryFuse filter to C#, along with tests and benchmarks. BinaryFuse filter is an incredibly clever data structure.

https://github.com/Genbox/FastFilter/tree/master

I opened this post in a tab 3 days ago, but now it says "5 hours ago". Someone is playing around.

A few years ago i picked up the old (but famous) cases of Brad Cooper and Casey Anthony as they have tons of available digital forensics evidence.

I double-checked the forensics work and found several mistakes in processes, assumptions and technical conclusions. I sent off my findings to people associated with Project Innocence - not because I found anything that proved Cooper or Anthony's innocence, quite the opposite. Instead, I wanted to let them know that forensics experts can make mistakes.

It is interesting that scientific work have fault-finding processes like peer-reviews, but forensics investigations in court cases does not.

C# started as a language tightly aligned with C++/Java, but has since moved to be something else entirely that is highly capable.

I assume that free-floating functions are global functions. You can achieve something similar by "global using". Put this in a file and tug it away somewhere:

"global using static YourStaticClass;"

Now you can call all the static methods on the class everywhere.

As for the using vs. naming convention, most people use the IDE and hover the mouse over the type to see its identity. Once you get proficient with the IDE, you can do it using shortcuts. However, if you really want to prefix all types with a shorthand of the package it came from, you can do it with aliases in C#.

Do you have any regrets about an algorithm/data structure and wish you picked something else?

"Maasai" is the correct spelling. They explain it on their website [1]

[1] https://maasai.com/conservation/maasai/

It isn't. You cannot derive an arbitrary length key with bcrypt.

For those reviewing the changeset: There are two places where they read a value directly from $POST into an $args array. There is no validation applied, which means an attacker can inject whatever value they wish.

How does it compare to the built-in CRC32 instruction? [1]

[1] https://www.intel.com/content/www/us/en/docs/ipp/developer-g...

We are saying the same thing. H0 is SHA-1 in your example.

The strength of an HMAC depends on the strength of the hash function; however, since it uses two derived keys, the outer hash protects the inner hash (using the same hash function), which in turn provides protection against length extension attacks.

The case I was making, is that weakhash(stronghash(m)) has the security of weakhash, no matter how strong stronghash is.

You are making two assumptions here:

1. More hash functions equals more security (hash encapsulation)

2. The attacker wants to know the content of 'm'

H0(H1(m)) has the security of just H0. Hashes are not made to protect the content of m, but instead made to test the integrity of m. As such, a flaw in H0 will break the security guarantee, no matter how secure H1 is.

Practically, H0(H1(m)) is the same as H0(m), as m is just "some data," and the result of H1 can be seen as "some data".

If your construction is H0(m0) + H1(m1) where m0, m1 are both halves of m, then the overall security is reduced to the weakest hash function. For example, a length extension attack in the weakest hash function breaks the overall integrity of the construction.

Datasheet can be found here: https://www.infineon.com/dgdl/Infineon-PASCO2V15-DataSheet-v...

A Danish cohort study showed the same results.

> Our findings do not suggest an increased risk of sudden sensorineural hearing loss or vestibular neuritis following mRNA-based COVID-19 vaccination.

https://portal.findresearcher.sdu.dk/en/publications/sudden-...