If you want to be the first or close to the first in the queue on a price level, you're there before it becomes big. So then your "risk-free" closing strategy doesn't work, because if you get traded against, you will have to close out your trade at a loss, since the price level is gone (because it wasn't big yet).

But if you wait until the level becomes big, you will no longer be at the front of the queue, so the strategy doesn't work.

https://www.reuters.com/article/muddy-waters-asia-short-sell...

See https://www.reuters.com/article/muddy-waters-asia-short-sell...

Getting the compute costs down will probably be a major obstacle to growth, since they'll have to keep prices high (19 USD/month) to pay for their infrastructure.

You can try them at https://www.teclis.com/ and https://tinygem.org/.

AFAIK some websites actively or passively block everyone except Google.

So costs per user will go down with the number of users as this fixed cost is shared between more requests/users.

And looks like more narrow requests for documents would be completed faster: "If Plaintiff decides to request fewer records, then FDA will be able to complete its processing at an earlier date."

An alternative is of course that we would treat requests by multiple people as more important, for example, if we assume that 1000 people requested these documents it would only take less than a month, but imho that's a huge slippery slope where information can effectively be hidden by inflating the size of it.

Say: you have two weeks to submit any requests. After that, everything gets released. It's your trade secrets after all.

If someone actually wants to understand how/why the vaccine was approved, the most sensible option IMO would be to tailor the FOIA Request more narrowly. Request the summary section: it should lay out the rationale, without diving into specific details that might need redaction. The only other alternatives I see are lobbying congress to either a) allocate more money for FOIA or b) make some categories/documents releasable as-is.

OTOH, asking for a third of a million pages--many of which no one has real intention of reading--does seem like a good publicity stunt.

[0] If participating in a clinical trial gets (potentially embarrassing) personal details leaked, we won't have nearly as many volunteers next time.

The correct way to deal with this here is probably either _NOT_ using nullptr, and instead using a special null object (similar to the end iterator); or using pointers instead of references (because you really want pointer behaviour).

Their fix is insane, and not something I'd want in production code. Unless you carefully vet your code and compiler version, you should never rely on undefined behaviour.

(There are some cases in the c standard that technically undefined but all compiler vendors have essentially agreed to handle in the same way; so those are fine. IIRC unions are a common example.)

If you mean type punning: That is fine in C (chapter 6.5.2.3 of the C11 Standard even mentions "type punning" in footnote 95), but not in C++, where it's undefined behavior.

I would just use memcpy. It works even when C code is compiled as C++, and modern compilers know what memcpy does and can optimize its call to a move operation: http://blog.regehr.org/archives/959

  int i = ...
  float f = *(float*) &i;

  union { int i; float f; } u;
  u.i = ...
  float f = u.f;

Just use memcpy :-)

No launched missiles though.

  General government gross debt [Percent of GDP]
  Country        Year  2012 2013 2014 2015
  China                  26   23   20   19
  United States         102  104  106  107

  let do_something (thing : Thing.t) (logging : [`With_logging | `No_logging])  =
  ...

  let do_something thing logging =
    let logging_as_bool = 
      match logging with
      | `With_logging -> true
      | `No_logging -> false
    in
    ....