T-MVP | Android AOP Architecture by Apt AspectJ Javassisit | Reactive Programming library

From the @Value javadoc:

Annotation used at the field or method/constructor parameter level that indicates a default value expression for the annotated element.

The @Value annotation is defined as follow:

There is no difference between a TaskCancelledException produced by either source. But, since you have a CancellationTokenSource allocated in scope, you can easily just ask it if it was set:

Thanks for reporting. This is just a bug in the compiler. The tuple when used as a field should be registering as a generic type and hence invalid in an unmanaged type. It appears to be evaluating as a tulpe instead and missing this check.

Good news is that in C# 8.0 this restriction will be going away. The type (int, int) is a valid unmanaged type.

The new System.Text.Json APIs do not support all the features that Newtonsoft.Json ("Json.NET") does, including deserialisation of read-only properties.

If you need this feature, switch to using Newtonsoft.Json as described in the Migrate from ASP.NET Core 2.2 to 3.0 Guide:

Yes, WebAssembly is being very actively developed. However, after version 1.0 was released the specification has moved into a more evolutionary development process. In other words, don't expect a big fanfare and v2.0, v3.0 releases - instead, expect new features to be proposed, debated, developed and shipped at varying rates.

You can find out more about this phased approach here:

https://github.com/WebAssembly/meetings/blob/master/process/phases.md

For a quick overview of the features that are actively being worked upon, take a look at the 'tracked' proposals:

https://github.com/WebAssembly/proposals/issues?q=is%3Aissue+is%3Aopen+label%3A%22%F0%9F%9B%A4+tracking%22

Finally, for a much more accessible overview of where WebAssembly is going, see this great video on the 'post-MVP future' from Lin Clark:

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

Answering the side-questions only, because I no longer work on Native Client. Google's plans are its own to speak for, so I'll make this a wiki.

Update as of 2017/05/20 NaCl isn't in glibc. This was the original libc which was supported, and took quite a while to clean up and upstream. It was only ever supported by NaCl's GCC toolchain. There's still support for musl libc, which works with the more up-to-date LLVM-based NaCl and PNaCl toolchain.

Update as of 2017/05/30 the Chromium team announced the fate of PNaCl and tentative roadmap of WebAssembly features.

Here are some Native Client features which you haven't mentioned:

• Out-of-process, which many consider a bug because it forces asynchronous communication. It allows guaranteed address space, which with 64-bit isn't much of an upside, and was critical to Native Client's double-sandbox design. WebAssembly doesn't have processes yet.
• Has blocking to and from the JavaScript event loop, through postMessageAndAwaitResponse. Also seen as a bug by many.
• Has many APIs through Pepper. Many mirror the web platform's APIs.
• Can do memory protection through mprotect (though execute pages are limited).
• POSIX signals can be handled.
• Supports computed goto and other irreducible control flow.
• Has some Just-in-Time code patching support.
• Supports weaker than seq_cst atomics.
• Has support for inline assembly, as long as it follows the NaCl validation rules.

Not all of these are in Portable Native Client, though. There's official documentation of differences.

There's no timeline for any of the post-MVP WebAssembly features. We don't want to rush anything, but we want to deliver one the most useful things first. It's a community group, so priorities are really driven by whoever gets involved. Implementations won't be able to tackle features all at once, but exploration parallelizes well.