HNHacker News
TopNewBestAskShowJobs

suavesito

123 karma · joined May 17, 2022

submissionscomments
suavesito··on iOS 17 automatically removes tracking parameters from links you click on
It is not a work around in the sense that they will be able to track you, they won't.

What Google tells them that if they use Analytics 4, they can use modelling to give attribution of convertion. In this case, attribution means not fingerprinting but percentage of people that was converted thanks to Ads. For other analytic engines they set the fields as 'not set'.

They day that in their models they aggregate data as geo, IP, and others and they won't give the fingerprinting data. The only problem is that they don't give details on the privacy preservation of their ML models. This means that if they fuck it up and give to much information, someone could try to reverse the aggregation (like doing a deconvolution) and do some fingerprinting.

suavesito··on C++ Implementation of StableDiffusion
Yes, both were created by the same person. On llama.cpp README says

> This project is for educational purposes and serves as the main playground for developing new features for the ggml library.

(Edit, typo.)

suavesito··on Fq: Jq for Binary Formats
Not only that, the README has a section called _Hopes_, the second bullet point being

> Inspire people to create similar tools.

suavesito··on ACM Software System Award Given to seL4 Microkernel
Absolutely, the problem I'm referring to is if Apple changed the kernel and not only built an application on top of it. I don't know, but maybe Apple just built an application on top, which seems sensible.
suavesito··on Pixel phones are sold with bootloader unlocking disabled
My viewpoint is not that it is fair or not for the carrier doing so. But that restricting freedom from a users device and software should not be allowed. This means that if the carrier decides to sell devices via some kind of credit it cannot take away the freedoms of the user (and future owner) of the device, but the carrier can decide simply to not sell devices via some credit.
suavesito··on ACM Software System Award Given to seL4 Microkernel
Except that making changes can actually invalidate the proof that were made. At least it matters in the sense that Apple should have made an arrangement so the things added didn't invalidate the correctness.
suavesito··on ACM Software System Award Given to seL4 Microkernel
And also GCC.
suavesito··on Roll your own JavaScript runtime, pt. 3
I don't want to start a 0-index war, but there is a great argument I read once and wave to share. Indexing can be tough as two different things, selecting or offsetting. When selecting you start from the first (1) option. When offsetting you move zero (0) from the first option.

0-index arrays express offsets, 1-index arrays express index selection. In C (and family) arrays start at zero because they offset, `a[i]` literally means `* (a+i)` (you actually can write `i[a]`, it will work and be valid). For other language selecting 1 base indexing is not a weird option, I'd argue.

suavesito··on A Little Calculus
That is because those are the traditional methods, and are easy to teach. And probably the curriculum hasn't been changed. Also, automatic differentiation is _hard_.

Numerical differentiation comes directly from the definition of derivative and symbolic is what you always did for exercises in your calculus classes.

Automatic differentiation come in two flavours, forward and backward modes. Forward mode is based on dual numbers [1], which is the

    quotient of a polynomial ring over the real numbers, by the principal ideal generated by the square on the indeterminate
That is ℝ[X]/≺X²≻.

Another way of thinking of this is to have an element ℇ different from zero, such that ℇ ²= 0 and hand wave the fact that the dual part of the number carry the derivative.

Backward mode builds a graph of computation and doing symbolic differentiation over the graph and compile down the derivative into runable machine code (it could be interpreted, compiled down to IR, neither the form or the execution environment changes the fundamental algorithm).

Maybe they are not really hard, but they are not easy either. Still I think they should be at least mentioned in modern courses.

[1] https://en.wikipedia.org/wiki/Dual_number

suavesito··on Fundamentally Understanding and Solving RowHammer
That is fundamentally different. Floating point computation not nearly as always needs to be done to the last digit of precision. For a lot of application 10^-8 is more than enough, for some even less digits might be enough. But fast calculation might be a lot more important if you're in a real time scenario or if you're doing HPC.

On the other hand, is not only row hammer attacks that cause bit flips, random bit flips happens, cosmic ray or decline of radioactive particles might cause one. And there is _no way_ to know if one happened on non ECC RAM (I know, ECC only reduces the probability of not noticing it, but it reduces that probability), and given that there is not way to respond.

If one random bit flip happens, best case nothing happens. If you are unlucky, maybe your system will crash. If you are really unlucky your data might end up corrupted and the OS might not even be able to detect it. Or maybe you were running a 100 hours calculation, and it might go wrong in the first minutes because of a bit flip and your simulation is ruined.

Floating point operations is about precision, witch can be studied and decided based on the needs of the application, bit flips are about data corruption.

suavesito··on As last module docks, China completes its space station
I mean, american people is as intelligent as anyone else. By the sheer number, is not rare to think that they should have more people of high training on difficult areas to master.

What happens to the US is that they "borrow" a lot of intellectual capacity from abroad, and they have been doing that for a lot of time.

Also, stealing IP and resources has been the eternal strategy of empires to build themselves, US and Europe included.

suavesito··on Correctness and composability bugs in the Julia ecosystem
> So arguing "LLVM has lots of correctness bugs" is not helping the case

It does not help the case about the correctness of Julia, but it does help the case about Julia having more bugs than other software (negatively for the other projects). Every library built with LLVM that touches those code paths will have those bugs.

Another thing to have in mind is that Julia ships patches for some of these, that are not used upstream yet. So Julia does not suffer from some bugs on LLVM that other projects might.

← PreviousPage 2 of 2