I would not be surprised in the least if that pattern existed in the wild. In fact, it's quite common to see this in C/C++ codebases too: people will use assert() to check a security-relevant property, and then disable those checks in their release builds "because it can't happen".

The typical correlation between weather and the economy is going to be fairly noisy across the dataset, but if you have 14 extra datapoints all saying there’s a catastrophic GDP crash in one year together with some coincidental weather effect, that’s going to bias the model hard. Notably, they also extrapolate losses forward all the way to 2100, so the effects of such a bias will compound.

`void main() void;`: Despite sort of looking like an independent declaration (which threw me for a loop initially), this is actually an old-style C function definition in disguise. This style of function definition looks like `int foo(a, b, c) int a; int b; int c; { return a * b + c; }`. Without the misleading spacing, the blog code becomes `void main() void; void; { puts("hello world"); }`, in which it is clear that this is an old-style function definition with two useless declarations attached (void;). This one is both standard and free of UB.

`int typedef[[]]$;`: This is a combination of a few features: (1) $ is allowed as a legal identifier by some C compilers, (2) [[]] is an empty C23 attribute specifier sequence (basically a standardized form of __attribute__), (3) && is both the familiar binary operator, and (as a GCC extension) a unary operator that takes the address of a label, and (4) `typedef` doesn't have to be the first keyword in a typedef definition. So, `int typedef[[]]$;` is simply `typedef int $;` - defining $ as a type alias for int. `int main($[[]]$)` says that `main` takes one argument - an `int` (typedef'd $) called `$`. `[[]]$:&&$&&$&&puts("hello world");` defines a label called `$`, then breaks down as `&&$ && $ && puts(...)` - take the address of the label `$`, logical AND the argument `$`, logical AND the result of `puts`. This one uses non-standard features ($ identifier, unary &&), but is free of UB.

`goto *puts("Hello world"), puts("Goodbye world"), exit;`: this is a computed goto statement that evaluates the comma-expression `puts("Hello world"), puts("Goodbye world"), exit`, which calls `puts` twice and produces the address of `exit` (implicit function-to-function-pointer conversion), using that as the goto target. So, in effect, it's two free calls to puts followed by `goto *&exit`. Note that this is UB, as it effectively tail-calls `exit(int)` with no arguments. This one uses the non-standard computed goto feature, and has UB, although it will probably work in practice.

`printf("Let's count: %d %d %d %d\n", i++, var[42], i++, i++);`: As far as I can tell, this is a bit of compiler weirdness (and is extremely UB). `var` is an array of empty unions, and takes up no space at all (although it will still have a defined address in the binary). `var[42]` is an empty union object and, at least on x86-64, takes up no space in a variadic argument list; it's therefore skipped over entirely when building the arguments to `printf`. This means that `printf` actually gets one fewer argument than expected; the missing argument just-so-happens to be a zero on the Compiler Explorer demo. Because this one is very UB (both because of the unsequenced `i++` and the incorrect argument list), expect the result to vary depending on the mood your compiler is in. I believe empty unions are non-standard, and this one is definitely UB; the result is very compiler- and system-dependent.

`(my_type)2 + 2`: `my_type` is a pointer to an anonymous empty union with `sizeof` 0, so `(my_type)2` effectively treats 2 as the base address to an array of 0-sized unions. Adding a number to a pointer is equivalent to taking an array address (i.e. `p + x == &p[x]`). Since the size of each element is zero, asking for the address of element 2 is still going to give the base address (2). Compare this with, for example, `(int *)2 + 2` (gives 10, assuming `int` is four bytes in size). Note though that there is again UB here, because the argument to `printf` is a pointer, but it's being printed using the `%d` specifier. This again uses the non-standard empty union, and it also invokes UB.

Chinese chipmakers weren't willing to use the first batch of domestic DUV machines because they simply weren't as good as foreign alternatives, and this made it doubly difficult for domestic machine manufacturers: they couldn't get revenue for selling machines, and they couldn't learn from their customers' experiences. The Chinese government, for example, is now apparently withholding Nvidia chips from being imported - despite the export ban being partially lifted from the US side - in order to incentivize local companies to use domestic NPUs instead.

Similarly, on a personal level, most of the (technical) folks I know here in China are using Claude/GPT models because they want to use the best models available. But, companies like Bytedance (Doubao) cannot use such models to serve their customers, and ordinary folks also cannot access these models without workarounds. As such, the market for domestic AI models is huge, which has uplifted a lot of the current AI model providers.

Ultimately, this creates a funny conundrum: sanctions mean that certain parts of the Chinese population can still access the "banned" tech - able to experiment with it and learn from it - while spurring domestic companies to seek domestic alternatives.

Actual technical writers know what to emphasize and what not to, based on the expected audience; good ones will gently add hints to expand that audience without compromising technical accuracy or content.

So…are you planning to hire only seniors who already know everything? Where do these seniors come from?

Of course, there’s lots of room for subjectivity here; what constitutes the “best” research is still at the whim of reviewers.

I'm living here (China, Beijing and Jiangsu) now, and there are exactly two cases in the past eight months where the "social credit" system has had any impact at all:

- To open "take first pay after" vending machines. These are vending machines which are basically big locked fridges; if your credit score is high enough, you can open the machines, take whatever drinks/snacks you want, and they'll use (I presume) computer vision to charge you afterwards. If you don't have a high enough credit score, tough, you can't use them. (But there's almost always normal pay-first vending machines nearby).

- To borrow mobile charging packs (powerbanks). Some operators will let you "swipe your credit" (check your credit score) to take one without paying a deposit. If your credit score isn't high enough, you first pay e.g. a ¥99 deposit (~$15USD) which gets returned when you return the powerbank, not a big deal.

That's...it. My credit score is high enough on only one platform (Alipay), so I get to try what happens with both "high" and "low" credit, and I can confidently say these are the *only* two cases where I have even been asked to show the credit score. I have taken multiple train trips, bought lots of stuff in stores and restaurants, etc. without ever touching the "social credit score".

P.S. I literally don't even know how to raise my credit score, and neither do many of the folks who live here - again, not that it matters, because the score is simply not that important.

- papers are written by AI (as pointed out in this article, and as obvious to anyone who spends a while actually reading recent AI research)

- papers are reviewed by AI (NeurIPS is doing an AI assisted review experiment - https://neurips.cc/Conferences/2026/ai-reviewing-experiment - and I feel the trend is moving towards AI reviewers whether we like it or not)

- papers are read, summarized and digested by AI, because there are just so many papers at leading AI conferences that nobody has time to eyeball them all

We are very rapidly automating humans out of the academic publication loop here.

I also think that, for larger projects, it's still useful to have real decompilation support; for example, Il2CppDumper works in tandem with ghidra-wasm-plugin to enable decompilation of Unity Il2Cpp projects, which are often enormous (100MB wasm files are not uncommon) and for which the symbols + types are invaluable.

As you might imagine, these attacks are aimed at less sophisticated users who may have no idea what Win+R even does, and who might be tricked into believing that this actually has anything to do with website verification.

The site you visited -- or one of the resources it depends on -- might have been compromised. If you're enterprising, you could probably determine where the malicious script is getting loaded from by looking in the page source.

Of course, this is already miles better than the current state of affairs where an old but popular package could become an infection vector at any time.

Of course, the counterargument is that ISPs should just be eating charges like that rather than passing them on to consumers. If they don't want to have to advertise confusing, long fee schedules, they shouldn't try to charge them in the first place!

Here's the decode script I used to produce the table above:

  rom = open('exsb1.dat', 'rb').read()
  ptr =  0xf6
  for i in range(128, 256):
      out = bytearray([rom[ptr] - 0x80])
      while rom[ptr+1] < 0x80:
          out.append(rom[ptr+1])
          ptr += 1
      ptr += 1
      print(i, hex(i), bytes(out))

  128 0x80 b'END'
  129 0x81 b'FOR'
  130 0x82 b'NEXT'
  131 0x83 b'DATA'
  132 0x84 b'BYE'
  133 0x85 b'INPUT'
  134 0x86 b'DIM'
  135 0x87 b'READ'
  136 0x88 b'LET'
  137 0x89 b'GOTO'
  138 0x8a b'RUN'
  139 0x8b b'IF'
  140 0x8c b'RESTORE'
  141 0x8d b'GOSUB'
  142 0x8e b'RETURN'
  143 0x8f b'REM'
  144 0x90 b'STOP'
  145 0x91 b'OUT'
  146 0x92 b'ON'
  147 0x93 b'NULL'
  148 0x94 b'WAIT'
  149 0x95 b'DEF'
  150 0x96 b'POKE'
  151 0x97 b'PRINT'
  152 0x98 b'CONT'
  153 0x99 b'LIST'
  154 0x9a b'CLEAR'
  155 0x9b b'CLOAD'
  156 0x9c b'CSAVE'
  157 0x9d b'NEW'
  158 0x9e b'TAB('
  159 0x9f b'TO'
  160 0xa0 b'FN'
  161 0xa1 b'SPC('
  162 0xa2 b'THEN'
  163 0xa3 b'NOT'
  164 0xa4 b'STEP'
  165 0xa5 b'+'
  166 0xa6 b'-'
  167 0xa7 b'*'
  168 0xa8 b'/'
  169 0xa9 b'^'
  170 0xaa b'AND'
  171 0xab b'OR'
  172 0xac b'>'
  173 0xad b'='
  174 0xae b'<'
  175 0xaf b'SGN'
  176 0xb0 b'INT'
  177 0xb1 b'ABS'
  178 0xb2 b'USR'
  179 0xb3 b'FRE'
  180 0xb4 b'INP'
  181 0xb5 b'POS'
  182 0xb6 b'SQR'
  183 0xb7 b'RND'
  184 0xb8 b'LOG'
  185 0xb9 b'EXP'
  186 0xba b'COS'
  187 0xbb b'SIN'
  188 0xbc b'TAN'
  189 0xbd b'ATN'
  190 0xbe b'PEEK'
  191 0xbf b'LEN'
  192 0xc0 b'STR$'
  193 0xc1 b'VAL'
  194 0xc2 b'ASC'
  195 0xc3 b'CHR$'
  196 0xc4 b'LEFT$'
  197 0xc5 b'RIGHT$'
  198 0xc6 b'MID$'
  199 0xc7 b'\x00\t'
  200 0xc8 b'G.'
  201 0xc9 b'F4'
  202 0xca b'K'
  203 0xcb b'5'
  204 0xcc b'H\x03'
  205 0xcd b'`C'
  206 0xce b'JO'
  207 0xcf b'Mr'
  208 0xd0 b'J'
  209 0xd1 b'L'
  210 0xd2 b'Hr'
  211 0xd3 b'HU'
  212 0xd4 b'HD'
  213 0xd5 b'I'
  214 0xd6 b']'
  215 0xd7 b'Fa'
  216 0xd8 b'H'
  217 0xd9 b'\x10'
  218 0xda b'H'
  219 0xdb b'7'
  220 0xdc b'H\x07'
  221 0xdd b'GV'
  222 0xde b'R&'
  223 0xdf b'IH'
  224 0xe0 b'G\\'
  225 0xe1 b'R\x1f'
  226 0xe2 b'O\x05'
  227 0xe3 b'Wh'
  228 0xe4 b'I5'
  229 0xe5 b'G'
  230 0xe6 b'F'
  231 0xe7 b'E\x0f'
  232 0xe8 b'HA'
  233 0xe9 b'S'
  234 0xea b'I'
  235 0xeb b'R\x1a'
  236 0xec b'Dy'
  237 0xed b'"'
  238 0xee b'Wy'
  239 0xef b'*'
  240 0xf0 b'S|'
  241 0xf1 b'j'
  242 0xf2 b'T|K'
  243 0xf3 b'U\x7f'
  244 0xf4 b'C'
  245 0xf5 b'XP'
  246 0xf6 b'('
  247 0xf7 b'LF'
  248 0xf8 b"'"
  249 0xf9 b'LNFSNRGODFCOVOMULBSDD/0IDTMOSLSSTCNUFMO'
  250 0xfa b'Ck'
  251 0xfb b'@'
  252 0xfc b'C'
  253 0xfd b'e'
  254 0xfe b'G'
  255 0xff b'S\x00'