shaded-enmity

Obligatory "What if English were phonetically consistent":

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

I'm still waiting for the ability to quickly share my drawings/writings with others over the internet. Really wanted to use it in architecture/design meetings instead of wonky jamboard.

Fair point, however I think that you're mistaking language design discussion in a closed group of PLT invested people, and a blog post targeted at general audience.

Visiting https://rust-lang.github.io/async-book/ I don't see any mentions of neither C# nor JS. The key difference here is the audience.

How is your suggestion not equivalent to "be familiar with full semantics of C# generics"? How does that help me with being productive using Go's implementation of generics, which has fundamentally different type system and syntax to begin with?

What is your point? Serious question.

If you tell me, for example, that Go generics are going to be like C# generics, then I have to be familiar with the full semantics of C# generics. Essentially you tell me that in order to understand X I have to understand Y first, that's not good. Consumers of your language are not, for the MOST part, PLT nerds.

Don't forget the precursors to RAZR :)

https://en.wikipedia.org/wiki/Motorola_StarTAC

Yeah, for example to check if a number is divisible by 3, we can use the digit sum and check if the result is divisible by 3, e.g. 153=(1)+(5)+(3)=9. This works in base-10, but we can generalize this by converting the dividend X into (3* X+1)-base then doing a digit sum. Let's say we want to check whether 238 is divisible by 17, so our base is 3* 17+1=52, 238 in base-52 is (4)+(30)=34=2* 17. If the convert-to-arbitrary-base operation was particularly cheap to compute, we could convert to base X+1 and check if the last number is 0 (same logic as: is_even = (i & 1) == 0) :)

Hmm, at school we were taught that the maximum temperature is such that wavelength of the emitted black-body radiation would equal Planck length, is this rationale no longer sound?

What do you precisely mean by genuine full-feature emulations of working computers? If the in-game computer is represented as some "physical model using fundamental particles" than each bit of simulated memory is backed by, I don't know, gigabytes of data about properties of those particles? Isn't what constitutes a bit strictly dependent on the process making the actual reading? How would the simulator know what is considered a bit of information within the simulated system, and intentionally map it 1:1 onto a real memory bank?

If we discard these problems, wouldn't that imply that if such mapping were possible, that the simulation would also have to be strictly Anthropic i.e. the only running "software" are minds being fed data as "sensory" input?

How exactly would the 1:1 bit correspondence work in practice? What is the binding between simulated and external bit? Wouldn't we need to operate at the edge of Landauer's principle to really rule out this possibility?

You seem to focus on step 2, e.g. having community and mindshare, while completely ignoring why all the people got there in there in the first place and why it gained such momentum, the step 1.

The main differentiator here is that this is able to deliver real-time performance at 24 fps -- not much interesting to current PC gaming standards (I'd trade detail quality for 144fps any day), but I guess that this has a huge potential for next gen console gaming.

Check out Genode: https://genode.org/about/index

I'd agree that the games do indeed run, but I have a big problem with the 'as fast as on windows' part - I have a beefy gaming rig (i7, 1080Ti, 144+ fps is a must), and most games run at 20% lower FPS compared to W10, while maxing both CPU/GPU to 100% utilization. There's also a lot of collateral problems, like borderless window support when running under i3, OBS and other streaming tools are rather quirky etc. I have tried 5 different distros and eventually went back with W10.

Apart from the issues you list, the biggest problem for me is game quality / support. The VR native titles, aside from few exceptions, feel and play like a tablet games, the non-native titles are usually riddled with rendering artifacts, despicable camera work or really unstable framerates (showstopper for me in VR).

Another interesting thing named after Prince Rupert is the Prince Rupert's drop for anyone interested: https://www.youtube.com/watch?v=k5MORochIDw

Assuming they integrate the technology tightly enough into the core of the engine could this potentially serve as a sort of "DRM" where you can, by setting a single flag in the UE4 editor, make the given entity or subsystem remote, and thus never exposing the actual guts of the system to the users? If so, I guess that this might enable a new way of integrating proprietary middlewares which are otherwise very hard to get your hands onto.

I think that if their technology also allows for dynamic scaling based on current/projected demand this could potentially save a lot of money since, at least from my limited experience of running various game servers for ~thousands of people, 70% of the time the demand is between 10-20% of the peak demand.

Great game, would be nice to be able to switch off controllers though - when I bumped into my G29 it immediately registered and I had to start steering :)

Link without popup: https://www.flightradar24.com/data/flights/ay666/#f31526e

I think you mean tile based rendering [1] - another huge plus of that architecture is the reduction of overdraw, where only the "most recent" write to certain block is effective.

[1]: https://en.wikipedia.org/wiki/Tiled_rendering

Some parts of the OCI use the patent-only OWFa: https://www.opencontainers.org/release-notices/v1-0-0

The prerequisite for mounting this attack is kernel code execution already [0]:

> We show that a malicious kernel driver ...

As per [1] the Power management unit is shared between the Application Processor (AP) and the Secure Enclave Processor (SEP) so this attack might work against iPhones as well.

[0] https://www.usenix.org/conference/usenixsecurity17/technical... [1] https://www.blackhat.com/docs/us-16/materials/us-16-Mandt-De...

> Finally, a big upside of setup.py, is that I can programatically generate information, whereas pbr's cfg file doesn't seem to allow that.

The problem with package manifests that are arbitrary scripts (Python, Ruby and probably others) is that you lose even basic introspectability into rudimentary parameters like name, version, dependencies unless your threat model allows for executing random code that people put into the setup.py. This can be mitigated by using complex static analysis carefully crafted for the specific task, but this isn't easy to implement and there is a non-insignificant amount of cases where the data cannot be legitimately decided. I'm just wondering how this is conceptually different from Pipfiles:

https://github.com/pypa/pipfile (Previous discussion https://news.ycombinator.com/item?id=13011932)

Exactly, but also, ROP is not solely about RET instructions, but the general technique is applicable to other forms of control transfer like unconditional absolute/relative jumps as well. Some time ago I did an analysis on this topic [1] using radare2 - I was curious what number of ROP gadgets is present in a healthy instruction stream (I call those implicit, and those are mostly comprised of function epilogues) and what number of gadgets can be formed by jumping into the "middle" of some instruction (explicit gadgets). The idea was to get rid of dangerous ModRegRm/SIB/XOP prefixes at the compiler level, see last table at [2] for example ModRegRM bytes - if your compiler decides to move something between RAX and {RDX,RBX} it will unavoidably emit C2/C3 bytes as well. Another thing are immediate and constant values, which are literally embedded in the instruction stream so if I have a code like:

   something = 0xc351c131485958

For which the compiler can generate:

   movabs rdx,0xc351c131485958

Just by using unfortunate value for something at the code level I've actually introduced a new gadget into the program:

   pop rax       // 0x58
   pop rcx       // 0x59
   xor rcx, rax  // 0x48 0x31 0xc1
   push rcx      // 0x51
   ret           // 0xc3

Not sure how it turned out, but I heard someone from GCC was trying to implement a mitigation strategy based on this idea.

[1]: https://github.com/shaded-enmity/r2-ropstats [2]: http://www.asmpedia.org/index.php?title=ModRegRM_byte_(32/64...