fyp

The reason people like idempotency is because it is great for "at least once" systems (as opposed to "exactly once", which is hard to guarantee).

But REST's version of idempotency isn't good for this. If you retry your request multiple times (due to flaky connection or whatever), it only guarantees the same server state if your duplicate requests are bunched up.

For example if you do a DELETE then create it again with a POST, if there is a duplicate straggler DELETE floating around it will end up redeleting your new recreation.

You can make anything idempotent if you add a "If-Match" header that returns a 409/412 if the current resource version doesn't match. Not only does this prevent the same request from being applied multiple times, it prevents losing updates when multiple different requests are submitted at the same time. Google cloud storage has a good example of this: https://cloud.google.com/storage/docs/generations-preconditi...

The only exception is on resource creation (POST) since there's no existing version/generation number to match on. You can get around that by letting the client generate the id with a random id and reject if the id already exists. I haven't decided if this is a good idea or not since the client can potentially choose really weird vanity ids (especially if you're using uuid in hex or base64). But if you don't expose your internal ids in any UI that seems fine too.

The paper also talks about reordering matrix multiplications by automatically adding parentheses (despite the fact that floating point multiplication is non-associative).

Is there a way to achieve this in Julia? If not what syntax might you introduce to do it? You can't really annotate just the matrices or multiplication operators since you are optimizing a whole expression.

The "three observations that aren’t really part of the story" were really interesting and doesn't seem to be fully resolved. Will you be discussing them more in the future post?

There's a lot of gray area between unsupervised and supervised learning. For example self-supervised learning: https://www.facebook.com/722677142/posts/10155934004262143/

For those out of the loop, most felt Half life 3 was officially dead after one of the lead writers Marc Laidlaw leaked the plot to half life 2 episode 3 to give fans closure:

https://www.marclaidlaw.com/epistle-3/

https://www.reddit.com/r/HalfLife/comments/6vwelo/i_edited_m...

So it's surprising to see more half life being worked on!

Original submission title was something like Chaosbook (which is also why there is a now nonsensical comment about Chromebook)

I thought this was going to be about the popsci book with a similar name: Chaos: Making a New Science

https://www.goodreads.com/book/show/64582.Chaos

If you include slang usages there's also jack off (jerk off), car got jacked (hijacked), he got jacked (muscular), doesn't know jack (jack shit), jack in (term from megaman battle network)

We probably need a technical rather than legal solution for this. The problem is that generative algorithms are susceptible to accidental memorization so you can't guarantee that the output will be transformative. For example, play with https://talktotransformer.com to see how many well known pieces of text it can spew out verbatim. It is very prone to derailing into a harry potter fan fiction regardless of prompt.

Other than copyright there are privacy considerations too. For example Gmail's Smart Compose is trained on users' private messages so you don't want it to memorize "private" details (such as credit card numbers): https://arxiv.org/abs/1802.08232

Is it possible to solve this by adversarially checking if the output is "original" enough or not? Or is that intractable, given how much resource our society already pours into making the same classification in court?

If he was doing olympiads in high school, he was already doing proof-based math then.

I think Terry Tao describes the stages of mathematical maturity really well: https://terrytao.wordpress.com/career-advice/theres-more-to-...

/r/OutOfTheLoop is good for stuff like this: https://www.reddit.com/r/OutOfTheLoop/comments/cdx1ve/why_ar...

In chrome, open developer tools then in "Application" tab, "Clear Storage" subtab, click "clear site data"

I haven't been following this field, but anyone know what happened to Neural Programmer Interpreters (2015)? It seemed like such a promising direction back then. It showed that a neural network can learn to use arbitrary commands to execute algorithms such as multidigit addition and bubble sort: http://www-personal.umich.edu/~reedscot/iclr_project.html

That seems like a much better demo of using blackbox tools as substeps in problem solving. Is there a reason why it shouldn't work when the blackbox is a more complex function like sympy's eval?

People are comparing this to the mobile revolution but I am curious to know why history should repeat itself. As far as I can tell there's currently no secret sauce that will make AR usable that Apple is uniquely in the position to monopolize (needing higher FOV, rendering opaque objects, etc).

Is it just the ability to drive cultural adoption to avoid "glasshole" stigma?

I use Quickbooks self-employed: https://quickbooks.intuit.com/self-employed/ which imports from your bank account and exports to Turbotax (with free filing). It will remind you to pay quarterly taxes too.

If you use a separate business bank account (which you definitely should), it's very easy to set up rules to classify each transaction in their respective category for deductions so it's mostly set and forget. My only complaint is their invoice feature sucks so you still need to look for something else for that.

Since AI is heavily parallelizable, it only matters that cost(as in dollars) will keep exponentially decreasing.

It doesn't matter if you can't double the transistor density of a single cpu if you can just double the number of machines. At the end of the day you still managed to double performance for the same price.

See https://en.wikipedia.org/wiki/FLOPS#Hardware_costs (note: in another thread someone noted that this wiki is outdated/inaccurate. If anyone have the relevant expertise they should help edit it)

For those who want to learn more, I would start with Mask-RCNN where you have a very similar architecture: one shared backbone with multiple heads that can be retrained for various tasks (bounding boxes, masks, keypoints, etc): https://youtu.be/g7z4mkfRjI4?t=628

Does it materially change the conclusion whether it's 8, 26, 100, or 1000 billionares?

I am saying the top 1% is 77 million people and you can narrow that group down by a lot and still make the same headline of top X surpasses wealth of bottom Y.

What about this link (2019): https://www.cnn.com/2019/01/20/business/oxfam-billionaires-d...

So top 26 instead of top 8.

Anyway my point is that all these news article lump the top 1% together even though you can make similar headlines about just the top 0.1%, 0.01%, 0.001%, 0.0001%, 0.00001%, 0.000001%.

Why is there an obsession over the 1% when the 0.0000001% (8 men) owns as much as the bottom 50% of the world? https://www.oxfam.org/en/press-releases/just-8-men-own-same-...

EDIT: correct headline

I think most people just don't realize how easy this is and you can even keep using gmail.

Most domain registrars have free email forwarding so you can forward *@domain.com to your gmail. This by itself is already good enough for signing up for things or resetting passwords.

If you also need to send from that domain in gmail there's just a few more steps: https://support.google.com/domains/answer/9437157?hl=en

Can someone share their experience with scaling pg's NOTIFY and LISTEN?

The use case I have in mind has a lot of logically separate queues. Is it better for each queue to have its own channel (so subscribers can listen to only the queue they need) or have all queues notify a global channel (and have subscribers filter for messages relevant to them). I am mainly confused about whether I need a dedicated db connection per LISTEN query and also how many channels is too much.

I have only played with webrtc before, but what is the problem with public stun and turn?

In case people missed the link, the reference implementation is an amazing post on its own: http://ppc.cs.aalto.fi/ch2/v7/

He gave several talks on CRDTs which are good intros:

https://www.youtube.com/watch?v=B5NULPSiOGw

https://www.youtube.com/watch?v=yCcWpzY8dIA

While we are on the topic of leverage and index funds, can someone explain leveraged index funds to me?

If I believe index funds are going to have a positive return, why not try to lever it up as high as possible? For example TQQQ (triple leverage) looks pretty enticing compared to QQQ.

The course notes for "Learning Discrete Latent Structure" should be helpful if you're interested in this topic: https://duvenaud.github.io/learn-discrete/