shiftingleft

Yes, it's great to see the adoption increase!

Monero has some limited form of privacy that's fairly good in practice: you can't determine which of N accounts is the origin of a transaction, where N is some fixed small number (6 in Monero I believe).

may i ask; why is your own location data so useful to you?

Does the M1 Ultra use a chiplet design like the Ryzen series? Otherwise the yields have to be awful.

> I also haven't seen any work of his using ML, that may just be a buzzword thrown in the PR release.

The first article you reference includes something about Support Vector Machines (SVMs).

> but it’s solved for most by a combination of just using the same passwords

That's not what I'd call a "solution"

what's the advantage of this over existing systems?

Is there any advantage over existing systems either for the lender or the debtor?

Archived version: https://web.archive.org/web/20210129191423/https://learn.rob...

Germany uses ~30% Coal in its energy mix, France less than 2%. Your argument is misleading at best, and targeted misinformation at worst.

Since you've repeated the same argument at least 5 times by now, even though others have informed you about the wrong conclusion, I must assume it is meant to misinform.

Oh, yeah.

I can't imagine publishing the entire source code of your entire stack even being possible.

What if you have some 3rd party vendor software in there? Are you required to publish their source too?

I haven't informed myself too much so please call out if/where I'm wrong.

In my mind the super quick version of this entire thing seems to be:

- GPL requires you to publicize your changes if you distribute the software.

- SSPL is more or less the same as GPL, but also requires you to publicize your changes if you offer the software as a service to others.

To me it really seems as if SSPL is a more modern GPL, fit for the SaaS world.

What am I missing?

WhatsApp also loses all e2e guarantees in the process. WhatsApp backups are not encrypted.

Signal on Android does support encrypted backups, however they're not automatically synced with anything. I think on iOS there's a different way to migrate your data, but it seems to require a PC.

I think we're talking about different things.

I would be interested in a way based on coding theory that solves the problem in the blog-post. Something of a form similar to this one would be a solution to me:

  def find_missing_number(nums: List[int]):
    # 1. Define some code C (possibly using nums)
    # 2. Encode a message using C (or interpret nums as a word or codeword)
    # 3. Do something with the word
    # 4. Find the locations of the errors in the word
    # 5. The locations of the errors tell us the missing number(s)

The answer on stackoverflow seems to use methods very related to RS decoding, however I can't quite squint enough at it to see, whether it could actually be solved using the exact same methods in RS decoding.

Thanks a lot for the detailed answer!

I'm familiar with some subset of coding and number theory, so you can assume at least some more knowledge (Galois Fields, or basics of RS codes for example).

Small nitpick: The Vandermonde matrix actually isn't square. It's a (k × n) matrix, (where typically k ≠ n). Therefore, it can't be invertible.

I see that many codes contain a parity bit (for example the extended Golay code), however I don't see how the operation of recovering "the missing number" could be implemented in terms of a code and its encoding/decoding algorithms.

I've found this on stackoverflow: https://stackoverflow.com/a/3492967/3868157

It describes a way to recover the missing number by constructing a Vandermonde matrix using the given numbers. This would correspond to constructing a generator matrix of a specific RS code [1]. However, after this I'm not so sure about the relation between encoding/decoding and recovering the missing number.

In the end they also factor a polynomial (that could be something analogous to the error locator polynomial?).

[1]: although I'm not sure if it's strictly an RS code

Ah, do you mean that solving the problem described in the blog-post helps actually using erasure coding, since it requires knowing which parts are missing?

You probably mean O(1).

Although: that's not true for arbitrarily sized integers either. Multiplication in O(1) implies P = NP (which further implies NP = PSPACE): https://cs.stackexchange.com/a/1661/129151

I don't see how the problem corresponds to erasure coding. Typically in erasure coding you know the locations of the erasures. Here, you don't know the location.

Maybe you can elaborate on how it relates to erasure coding?

I think in erasure coding you typically know the locations of the erasures: If a disk fails, you know which one failed.

However, I don't see how you would know the locations in this problem?

Maybe you can elaborate on how this problem relates to erasure coding?

Could you share a source about register allocation describing optimizations such as the one you described?

Your note is very important, I think it would be good to give it more emphasis.

What works flawlessly, however, is:

  In [1]: a = None
  In [2]: b = 0
  In [3]: (a is None) ^ (b is None)
  Out[3]: True

Alternatively, as suggested in another comment, you can use inequality as a replacement for XOR:

  In [4]: (a is None) != (b is None)
  Out[4]: True

Another error prone pattern is the following:

  In [5]: a or b
  Out[5]: 0

Which can behave differently depending on the order of elements/values:

  In [6]: b or a
  Out[6]: None # should be 0

Since b is zero, it doesn't count. Less error prone, but also more verbose is:

  In [10]: a if a is not None else b
  Out[10]: 0

I think this is a fair assessment, and would like to add that the "time to first plot" is also quite the usability issue.

Julia is using LLVM for code-gen has to compile a lot of code before you can actually use stuff like plots.

It takes ages to get a Pluto Notebook up and running, while a jupyter notebook is available instantly.

I guess whether it's effective to migrate a code base depends a lot on where your costs are.

If you pay 500k$ for compute, it might become worthwhile to invest time into rewriting hot paths.

Quite sad actually

The Great Filter thesis is that there has to be one or more very low probability events in the Drake Equation.

However, as per my other comments, you can update the distributions of your parameters in different ways, such that none of the events in the Drake equation have a particularly low probability.

Then the Great Filter disappears and there's no specific or few set of events to point to - it's just that the probability of all events succeeding in combination is extremely low.

Yeah - but they don't have to be much smaller.

Let's use the simple example you reference from the paper. If we just use the mean as point estimates, then indeed we obtain an extremely low probability that there's no other intelligences:

  def prob_of_no_intelligence_in_galaxy(p):
      prob_of_intelligence = pow(p, 9)
      planets = 100e9
      return pow(1-prob_of_intelligence, planets)

  prob_of_no_intelligence_in_galaxy(0.1) -> 3.720086311124783e-44

However, there is already a 82% chance of an empty galaxy if the parameter p is halved:

  prob_of_no_intelligence_in_galaxy(0.05) -> 0.8225792614407508

Now of course halving every probability is a lot, however now there's no single or few events that have a very low probability of happening. The Great Filter disappears.

See also my other comment here: https://news.ycombinator.com/item?id=25811359

From the website: "The Great Silence implies that one or more of these steps are very improbable; there is a "Great Filter""

The paper argues against this in that you don't need a few very improbable. In fact, there are many parameter choices where none of the probabilities in the Drake equation are particularly low, yet the resulting number of intelligences is still staggeringly small.

tl;dr: All parameters can be a bit lower. Then you don't need any events that are extremely improbable.

The Fermi Paradox has essentially been resolved: https://arxiv.org/abs/1806.02404

This explanation is much more plausible than a Great Filter. Here's a great comment summarizing the argument very intuitively:

https://news.ycombinator.com/item?id=17562439

I also found this one very helpful:

https://news.ycombinator.com/item?id=17564379

Is the gaussian mixture model required for this? Can't you just use the nearest neighbor?

Good luck! I hope you safely navigate(d) out of your crisis.