tynorf

IIRC: it is to leverage the OS page cache rather than having a separate buffer pool in user land. By default lmdb uses normal pwrite/fsync for the write path, but can optionally use a writable mapping and (presumably) msync.

However, some people think there are problems with this usage: (pdf warning) https://www.cidrdb.org/cidr2022/papers/p13-crotty.pdf

The computer has 18GB of total RAM so I would hope that it’s already trying to conserve memory.

It’s kind of humorous that everyone interpreted the comment as complaining about Chrome. For all I know, it’s justified in using that much memory, or it’s the crappy websites I’m required to use for work with absurdly large heaps.

I really just meant that at least for work I need more than 8GB of RAM.

Chrome on my work laptop sits around 20-30GB all day every day.

Perhaps a small nit, but the “design space tree” looks more like a directed graph.

You can try setting `export PYTHONWARNINGS="ignore"` to suppress warnings.

Anecdotally, I fly round trip out of SEA ~3 times a year and experience very bad turbulence on about half the flights. Earlier this year it was bad enough to suspend drink service.

At Amazon you can't even open the building next door without approval.

This is not true.

This is a very important point.

I'd argue all these "publish your DB schema as a GraphQL endpoint" frameworks that seem to proliferate have done a lot of damage to GraphQL's reputation. Strongly coupling data to presentation seems like such an obvious anti pattern, yet tools doing just that seem to be very popular for some reason.

You might be interested in this: https://brandur.org/idempotency-keys

The objects directory stores every file (and tree, commit, etc). Pack files are an optimization storing diffs.

Cassandra does not make you immune to database issues: https://monzo.com/blog/2019/09/08/why-monzo-wasnt-working-on...

The interior has been aluminum, but the band around the outside has been stainless steel.

Ceramic Shield front, Textured matte glass back and stainless steel design

https://support.apple.com/kb/SP875?viewlocale=en_US&locale=e...

Yes, that would be a different reason to prefer worktrees (that I mostly agree with). I was responding to the specific storage space claim.

FWIW, local git clones use hard links for object files, so share a lot of their data.

https://www.git-scm.com/docs/git-clone#Documentation/git-clo...

I'm pretty sure part of the contract with gzip (and compression in general) is that applying it N times is undone by decompressing N times.

The size definitely gets bigger with each iteration:

  $ echo text >0.txt
  $ for i in {0..9}; do                             
  gzip <$i.txt >$((i + 1)).txt
  done
  $ ls | sort -n | xargs -n1 wc -c
       5 0.txt
      25 1.txt
      46 2.txt
      69 3.txt
      82 4.txt
     105 5.txt
     120 6.txt
     143 7.txt
     161 8.txt
     184 9.txt
     207 10.txt

Something like this? https://stop.lying.cloud/

I believe orf is talking about the read(2) syscall, which is blocking.

OWASP is a good resource for web security related topics. i.e. https://cheatsheetseries.owasp.org/cheatsheets/Authenticatio...

I think the classic example is article list with author details. You load the articles (one query), then for each article you load its author (N queries). Naive use of an ORM causes this:

  articles = Article.load(limit=10)
  for article in articles:
    # .author implicitly runs a query
    author_name = article.author.name

I believe being lenient in accepting input is what leads to SSRF attacks (HTTP request smuggling via disagreeing `transfer-encoding` and `content-length` headers).

Probably either via a third party service (such as AWS secrets manager), or mounted as files scoped to the user your process is running as (which is not root, right? :) ).

Just a point of clarification: native app notifications on iOS are absolutely opt-in. If the app wants to send notifications it requires a dialogue and user confirmation.

Disappointingly, Apple makes an exception for their first party apps.

Out of curiosity, how many windows/tabs? I routinely launch FF with dozens of windows/hundreds of tabs and I've never had macOS kernel panic in that case.

Curious: what is your definition of strongly typed, contrasted with weakly typed? How about static vs dynamic?

I haven't actually watched it in a while, but are you referencing this talk by Chandler Carruth? https://youtu.be/yG1OZ69H_-o

Unfortunately:

  E183: User defined commands must start with an uppercase letter

Your protobuf messages are changing that much? My condolences.

ETA: Also, you already are needing to add code to every encode/decode point for the `map[string]interface{}` handling. :P

One technique I use is to create a struct that mirrors the layout of the target struct, then just cast between them. So if you have a

  type Person struct {
    FirstName string `json:"first_name"`
  }

  var doc struct {
    FirstName string `json:"name"`
  }
  json.Unmarshal(data, &doc)
  person := Person(doc)

AFAIK that is exactly how restic works. You use `restic forget` to remove the roots (snapshots), then `restic prune` garbage collects unreachable blobs.

ETA: However, nearly all data in restic is encrypted. This includes the index files. So you still need to have the encryption key to look at snapshots and walk their trees.

Many (most? all?) allocators are guaranteed to give you back aligned pointers.

For instance, jemalloc(3) on amd64 platforms will give back 16-byte aligned pointers:

  [...] The allocated space is suitably aligned
  (after possible pointer coercion) for storage of any type of object.