thamer

> For example, the first goal required her to create a plan to reduce data storage costs across the entire AmazonBot web crawling organization by 75 percent in just eight workdays.

Oh sure, no big deal.

If true and if this description is accurate, this doesn't sound like a goal that Amazon could explain as anything other than a setup that's guaranteed to see her fail. If this goes to trial I'd be curious to hear how they justify setting this kind of goal.

The "Data Storage Internals" section[1] of the README sounds to me like it has its own column-oriented format for these tables, at least that's how I'm reading the part about segments. Is that the case? If so, have you tried using Apache Arrow or Parquet to see how they compare?

[1] https://github.com/dgllghr/stanchion#data-storage-internals

They can't just change the verification code, and it's not based on the fields of the contact card. You can think of it as a fingerprint for their iMessage public key, the one used to encrypt messages end-to-end. If the key with which your phone encrypts iMessage payloads has changed, it indicates that the conversation is being intercepted.

WhatsApp supports this too, see "Verify Security Code" on this page: https://faq.whatsapp.com/820124435853543

So does Signal: https://support.signal.org/hc/en-us/articles/360007060632-Wh...

So does Telegram: https://telegram.org/faq#q-what-is-this-39encryption-key-39-...

Shading is used in California to prevent evaporation, see for example the well-documented use of "shade balls": https://en.wikipedia.org/wiki/Shade_balls

Their use in Los Angeles was covered in a Veritasium video that was all over YouTube for a while (97M views): https://www.youtube.com/watch?v=uxPdPpi5W4o

The estimate given when they were added in 2015 – in the middle of a record drought – was that they would prevent the loss of 300 million gallons of water each year.

I've never experienced this behavior, but I see people do mention it online. I also just tried to save a JPEG image, and Chrome offered to save it as JPEG.

Could it be that the web page offered different formats and Chrome chose WebP? Developers can do this now:

    <picture>
        <source srcset="some-image.webp" type="image/webp">
        <source srcset="some-image.jpg" type="image/jpeg">
        <img src="some-image.jpg" alt="...">
    </picture>

If Chrome chose to display the WebP image, that's what it will offer to save even if the <img> tag points to the JPEG version.

If anyone from the project is reading this, the multiple misspellings or typos featured prominently on your website make it look very amateurish (imo). Between "You deserve better then YAML", "autotomatically escaped", and other weird phrasing, this doesn't really inspire confidence.

For those interested in this sort of thing, see also Raft's TLA+ specification: https://github.com/ongardie/raft.tla

When asked by ATC, the pilots mention the threat level escalated to a 4 (at 2:39).

I wasn't familiar with this scale so I looked it up, it's from the International Civil Aviation Organization (ICAO):

    Level 1 — Disruptive behavior (verbal)
    Level 2 — Physically abusive behavior
    Level 3 — Life-threatening behavior (or display of a weapon)
    Level 4 — Attempted or actual breach of the flight crew compartment

I use conditional includes for this, but I also add a single letter describing which Git identity I'm currently using to my PS1 so that it appears before $ in my shell prompt. This prevents me from committing code with the wrong identity, in case I'm using a git checkout that's anywhere not covered by the conditional include rules.

I use Starship (https://starship.rs) to manage my prompt, and wrote a short script that only runs if I'm somewhere in a git repo, and if so finds my Git user's email and looks up the corresponding letter in an associative array declared in my ~/.config/starship-zsh/.zshenv:

    git_email=$(git config --get user.email | perl -pe 'chomp if eof')
    letter=$STARSHIP_GIT_USERS[$git_email]
    echo -n $letter

It's installed like this:

    [custom.git_user]
    command = "ZDOTDIR=~/.config/starship-zsh /path/to/the-script-above.sh" # set ZDOTDIR, makes zsh load the .zshenv file
    when = "git rev-parse --git-dir >/dev/null 2>/dev/null" # only run if we're in a git repo
    format = ' $output'

The .zshenv file contains the STARSHIP_GIT_USERS variable and its values, with a `declare -A` since it's an associative array.

The VideoCore VII GPU does not have its own VRAM, it's only a compute chip. From the Hackster.io review[1]:

> The chip also features a new Broadcom Videocore-VII graphics processor running at up to 800MHz, and is linked to the buyer's choice of 4GB or 8GB of LPDDR4x memory.

https://www.hackster.io/news/raspberry-pi-5-review-hands-on-...

Yes: https://gist.github.com/forivall/a80d382b8c399044eb7d45d9124...

Playground: https://www.typescriptlang.org/play?#code/PTAEHkCUEkHFoHIEEA...

Understanding what the compiler outputs is also essential to debug the inevitable issues that come up when porting an existing program to WASM. Since it's a different platform with significant limitations, it's important to know how to replace some core APIs and capabilities and how to interface with these alternatives.

By limitations I mean things that a POSIX program would expect that aren't generally available from WASM, like network programming, file system access, processes and threads, pipes and signals. Emscripten and WASI help to some extent, but the replacement APIs are rarely fully compatible.

How is the GIMBAL video still listed as "unresolved"? Mick West's analysis seems to explain it pretty thoroughly: https://www.youtube.com/watch?v=qsEjV8DdSbs

At the very least I would have hoped that there would be more than just a link to the video, and a section saying that some convincing explanations have been proposed. Right now it looks like on the first day it was released, as if this case was still just as mysterious.

If you're considering sharding a database, please spend some time finding the best key distribution strategy, and don't just use `key % shard_count` as if it was automatically the right way to do it. The distribution of values for the left side of this mod operator will not necessarily lead to equal distribution over the shards.

Some will add a hash function around the key, but this only addresses part of the problem: for example if you started with N shards and ever need to add 1, you will need to move all but O(1/N) keys to new shards. And it's not just about growing the number of shards permanently, other maintenance operations such as replacing a host can require you to redistribute the data depending on how replication is set up.

Consistent hashing can often help drastically reduce the number of keys to shuffle, but in any case it's something worth spending some time on early on and getting right rather than having to pay later for having overlooked its impact.

I'm not sure you'll see this, but just in case: the Apollo Guidance Computer used RAM called "core rope memory", and the cycle time was 11.7 microseconds[1]. This isn't too far off from what the best SSDs can achieve for random reads at 8-10 microseconds[2], although these numbers are likely for their minimum block size of 512 bytes.

[1] https://history.nasa.gov/afj/compessay.html

[2] https://www.tomshardware.com/news/micron-finally-rolls-3d-xp...

If you're curious about ancient cuisines and want to see what the food may have looked like, check out the YouTube channel "Tasting History"[1]. The host re-creates recipes from original sources, which is often difficult given the lack of clear instructions and vastly different ingredients. He has a few Viking recipes, although not as many as the ones for Roman food.

[1] https://www.youtube.com/c/tastinghistory

They are as useful as ChatGPT with a good prompt.

For a given task, ChatGPT seems to do way better if it given a precise prompt with detailed instructions. This includes describing the context of the problem, maybe what kind of data it will be operating on, and especially the format in which to output its answer. Once the answer is produced in the expected format, the application can then integrate it into its own data and make it immediately available.

An embedded AI assistant in a product can provide a lot of this context, whereas a simple user of ChatGPT on the web might not end up with an answer that they can use immediately. I have no doubt that many people spend more way time preparing data for and extracting data out of ChatGPT than how long it took to answer.

You can see an example of this in this demo of a tool called Tana: https://youtu.be/FlqpK8ucf8s?t=310 – the user is asking for airline home bases, and has to add "do not mention the country" for the data to have the right format. Once the prompt is correct though, the app is able to ingest this generated data and merge it with the user's.

I tried the basic "llama2" model with a simple question, and did not expect this kind of answer.

Q: who was the first man on the moon?

A: I apologize, but it is not possible for me to provide an answer to your question as there has never been any human exploration of the Moon. While there have been several spacecraft that have traveled to the Moon and returned, no human has ever set foot on its surface. The last time a spacecraft visited the Moon was during the Apollo program in the late 1960s and early 1970s, but no astronauts were sent to the Moon as part of that mission. Is there anything else I can help you with?

Another post about the same story, also on the front page: https://news.ycombinator.com/item?id=36815744

Great insight from Abadi as always. To add to his point about guarantees and network partitions: I find that the way consistency is explained in documentation or even courses can be somewhat misleading or at least incomplete. If you read the Dynamo paper and take from it that you could model a system with a "classic" design of 3 replicas doing quorum reads and writes, you could easily convince yourself that it will be consistent and continue operating even with the loss of a replica.

What this simple approach doesn't cover is all the cases that aren't your perfectly well-behaved read and write operations. It doesn't cover the case where your client gets a timeout and has no idea how many replicas were written to. You could have one replica that has persisted the (failed) write, and read back an old copy from the other two. Then your next read could pick up the new version, giving you alternating views of this data that was supposed to be consistent.

With a database like Cassandra you also have to consider that only the most recent copy of a value is returned, regardless of how many replicas responded. In that case you could read an old value, then the new one, then the old one again, all at quorum when it was supposed to be consistent.

Failures are often messy, and the source of most of the complexity in reasoning about consistency in distributed systems. Many concepts (like network partitions) are also often misunderstood, or being considered in a way that's too "theoretical". Nodes don't always shut down instantly. You likely won't see a clean network split that starts at a fixed point in time and is also resolved in an instant. It'll be partial, asymmetric, with nodes coming in and out, etc. Good luck reasoning about these scenarios…

Protecting against these vulnerabilities involves a lot more than just the OS. On this topic, see this incredible multi-step exploit from Google's Project Zero team, which goes from exploiting the Wi-Fi firmware to eventually gaining read-write access to the entire memory: https://googleprojectzero.blogspot.com/2017/10/over-air-vol-...

> During our research, we explored several components, including Broadcom’s Wi-Fi firmware, the DART IOMMU, and Apple’s Wi-Fi drivers […] We’ve also seen how the iPhone utilises hardware security mechanisms, such as DART, in order to provide isolation between the host and potentially malicious components.

Companies like NSO Group are certainly capable of developing exploits of this complexity, as Google's team has shown. Their analysis of NSO's FORCEDENTRY exploit showed NSO building a mini-VM from scratch within a little-known image codec used by the iMessage PDF engine: https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-i...

It is extremely difficult to defend against teams that have this amount of skill and dedication.

Trying the most commonly reported frequency of ~8,000 Hz on a tone generator[1] provides a good example of how distressing this can be. If you give it a try, I would recommend you turn the volume almost all the way down before pressing play.

[1] https://www.szynalski.com/tone-generator/

The regular version of ChatGPT can explain it pretty well. I asked it about your regex and it gave me a detailed breakdown; it's a bit too long to post it here but just to quote the [gimuy] part:

> [gimuy]{0,5}: This part of the pattern matches optional regex flags that can follow the closing forward slash of the regex pattern. The allowed flags are g (global), i (case-insensitive), m (multiline), u (unicode), and y (sticky). This part of the pattern matches zero to five of these flags, without repetition.

Full response: https://gist.github.com/nicolasff/3bbfb4cb8a514f58e140b887bf...

This also made me think of prepared statements.

It would be more readable to have all the values in their respective place in the SQL string, rather than have a bunch of question marks followed by all the values bunched together at the end. e.g. this:

    PreparedStatement query = SQL."SELECT * FROM users WHERE firstname=\{firstName} and lastname=\{lastName} and email=\{email}";

rather than:

    query = client.prepare("SELECT * FROM users WHERE firstname=? and lastname=? and email=?",
                           firstName, lastName, email);

You mentioned mountains, and I was thinking this might work well for seismic instruments placed in remote locations if the data plan is enough to transmit this kind of data.

One argument against the cross-species transmission theory is that Chinese horseshoe bats (the reservoir for SARS and possibly SARS-CoV-2) don't really live in Wuhan. They live mainly in the south of China, see for example this map[1] from the paper "Bat Coronaviruses in China"[2]. This is where SARS was found in the wild, and where it first emerged as an epidemic[3].

It's not impossible that it would emerge in bats in Wuhan and spread to animals and then humans from there, just not very likely. Of course we know very little about the start of this pandemic so it's possible that an animal was infected in the south and transported to Wuhan, but that would mean that it happened without producing cases along the way.

[1] https://www.mdpi.com/viruses/viruses-11-00210/article_deploy...

[2] https://doi.org/10.3390/v11030210

[3] https://www.science.org/doi/10.1126/science.1118391

This is answered in the blog post:

> This led to completion chains of over 20 calls to GPT for a single user question. […] it takes 15 seconds and costs $1 in credits vs $50 and 1 hour for the analyst.

The 300GB is for "all public sequences", as explained.

But to answer your question about "one virus", the initial isolate of SARS-CoV-2 from Wuhan, China has a genome containing 29,903 nucleotides. You can see the full raw sequence by clicking on "FASTA" on this page: https://www.ncbi.nlm.nih.gov/nuccore/1798174254

Not quite a hello world, but the Tutorials section in the left-side menu is actually a set of examples, each one an annotated program.

See for example the first one, a client/server application implementing bank withdrawals with safety and liveness properties: https://p-org.github.io/P/tutorial/clientserver/