hueho

It's a VM feature - value classes will use it when they land eventually. https://openjdk.org/projects/valhalla/

The "benefit of someone else" in this scenario is the site operator not having their website down or their hosting bills unsustainable because of misbehaving (which are 99% of current) web scrapers from AI companies.

The README itselfs admit that this is an nuclear option. https://github.com/TecharoHQ/anubis

Most JSON libraries in typed languages require this for data binding to complex types though.

> Sucrose looks at code and tells the "compiler" to only parse params and skip parsing other parts of the request like body, query, headers entirely as it's not need.

My understanding is that just offering a request object with lazy accessors would solve this issue, although the accessor itself would have some overhead in repeat accesses.

> Elysia has two special optimizations for response mapping functions: mapResponse and mapCompactResponse.

This section feels a bit abstract - some transformation examples would be nice.

The affected employees are in the UK and Canada branches, with their own local unions.

Wasn't aware of that, can you send a link explaining?

But the trillion dollar industry also signed this statement, that's the point - high ranking researchers and executives from these companies signed the letter. Individually these people may have valid concerns, and I not saying all of them have financial self-interest, but the companies themselves would not support a statement that would strangle their efforts. What would strangle their efforts would be dealing with the other societal effects AI is causing, if not directly then by supercharging bad (human) actors.

It's amusing that this is not an summary - it's the entire statement. Please trust these tech-leaders that may or may not have business with AI that it can become evil or whatever, so that regulatory capture becomes easier, instead of pointing out the other dozens of issues about how AI can be (and is already being) negatively used in our current environment.

> And it valid for them to want to do so.

Sure, if they don't make it everybody else's problem. Not to defend MS too hard, but they supported Windows XP with security updates for 18 years. At some point software needs to be "finished", and once it is, all responsability falls upon the user.

The enterprises with competent IT that will airgap their XP machines to keep running the control plane for their factory probably "know better" than MS, the power user who refuses to use a Linux distro for their Pentium 3 box or who will disable Windows Defender and run random scripts on the internet to "debloat the OS" without understanding it, or the ones who run LTSC and then complain that their games aren't working - they all absolutely don't know better, but unfortunately they tend to be the louder voices in the conversation.

FWIW this was largely fixed in 24 (I think there are still some edge cases relating to FFI functionality), and the 25 LTS should be coming this month.

Don't even know what the product is about, but it went into my shitlist for redirecting me always to a badly machine-translated page, not understanding en-us as a language code in the URL, and not having a language selector.

Plenty of people dislike the perceived bload in GNU utils - for them a rewrite from scratch is a feature, not a bug.

Java bytecode was originally never intended to be used with anything other than Java - unlike WASM it's very much designed to describe programs using virtual dispatch and automatic memory management. Sun eventually added stuff like invokedynamic to make it easier to implement dynamic languages (at the time, stuff like Ruby and Python), but it was always a bit of round peg in square hole.

By comparison, WASM is really more like traditional assembly, only running inside a sandbox.

A sidenote is that Wii actually ran a separate operating system (nicknamed IOS by the community) in a dedicated ARM processor (Starlet), that was responsible for performing the majority of device input/output, including disk access, internal and external storage, and notably in this case, networking - the TCP/IP stack was implemented entirely there.

Besides running on a weaker CPU, IOS can access (for exclusive use) some of the main system memory, but it was usually about 12-16MB to not starve the actual games running on the main CPU (https://wiibrew.org/wiki/Memory_map), which can help explain why everything except for the actual games was so slow.

Originally, code running on the main PPC CPU could not access directly most of the IO related hardware at all (only GPU/display output and wired controllers - the bluetooth stack was also on IOS AFAIK, but the Wiimote drivers themselves were userspace), so even the Linux ports had to "proxy" some hardware access through the IOS, but later after reverse-engineering the full boot process, people were able to create a replacement IOS that could enable full access through a special register: https://wiibrew.org/wiki/MINI, enabling full-speed Linux ports, and since that functionality is about a decade old now, I would guess that the NetBSD port also takes advantage of that.

Just as an side note, not relevant to anything in particular, Foundation DB itself is open-source (https://www.foundationdb.org/), but the integration layer used by Deno to make it the backend for Deno KV is not.

Although, from reading the Foundation DB docs and checking the Deno KV API, I honestly suspect it is a thin layer.

Self-hosting FDB is somewhat inscrutable though, so their value add is in not having to handle infrastructure while being backed by FDB.

> Go actually ships with a quite forward thinking SQL interface

SQL is low hanging fruit in this regard, because you just need to standardize the lowest common denominator flavors of SQL types for deserialization and then it's just juggling SQL queries around.

JDBC for Java does the same as database/sql and it's from 1997. ODBC is from 1992.

The serial GC is a limitation of the community (OSS) edition. The enterprise proprietary version has G1 support.

I hope Oracle will let it drip it down to the CE, but it's their project, their monetization strategy.

Source is not easily licensable.

> run games in almost native performance in windows guest vm?

No, vfio is still the most recommended option.

This is essentially something like VirtualBox or VMWare 3D acceleration - the host is still the "owner" of the GPU, and has to juggle receiving OpenGL commands from the guest and sending the render results back to it, with lots of overhead. But easier for users than setting up passthrough or using proprietary GPU virtualization solutions.

People pointed out that there is a similar project for Vulkan, already being used in production for ChromeOS, called Venus. Should be the one to watch nowadays.

As far as I understood this is very much intended to be used in multi-threaded code as well. If you are sure that your object won't be called in multiple threads you can just do the simple "if(ref == null)" without locking and it should be reasonably fast - just not constant-foldable by the JVM.

There isn't a daemon to speak off, they are shared libraries that you load and call functions on.

I don't know much about R, but if it considers the whole memory space of the R process, it probably counted the memory consumption of the libraries themselves as well.

In fairness, Java 17 has just been released; it's possible new custom patches will be introduced in future Corretto patch releases.

Still, the fact that Corretto 11 had so few backports is encouraging.

> Kotlin data classes can be used with the JPA contrary to Java records.

Arguably this is more of an issue of JPA than an strict advantage of Kotlin: JPA was designed at a time where the general consensus was to primarily use mutable data, and was heavily influenced not only by existing Java ORM APIs, but by their implementations.

Kotlin itself supports JPA by the use of a compiler plugin, which is a good enough solution, but nevertheless, not one native to the language. Data classes mostly work by accident, but pretty much any documentation you will find points it to _not_ use them with JPA.

This is a classic troll text.

Lightweight threads like in Go or Erlang are not happening anytime soon as a C++ standard because they require much more complex runtimes to be decently implemented (whereas traditional threads can just delegate straight to whatever OS threading is available).

There are coroutines though, that can fill some of the same needs covered by lightweight threads: https://en.cppreference.com/w/cpp/language/coroutines

> why Nintendo rarely outsources games

That's an overstatement: Nintendo co-develops a lot of titles with other studios, outsource a lot of their smaller IPs (mostly to Japanese studios), _and_ is being rather friendly to letting people do smaller spinoffs of their big properties.

Examples of third-party colaboration, in no particular order:

- Koei Tecmo co-developed Fire Emblem: Three Houses, did both Fire Emblem Warriors and Hyrule Warriors, which are franchise spin-offs using their Dynasty Warriors engine and gameplay, and Nintendo trust them so much that their next canon Zelda game will be a Breath of the Wild prequel developed by them, using the Hyrule Warriors label.

- Bandai Namco is more or less the main developer of Super Smash Bros since the Wii U/3DS iterations, with Sora Ltd being essentially just a consulting company run by Masahiro Sakurai. Bandai Namco is also co-developing the new Pokemon Snap, and developed Metroid: Other M.

- Capcom developed both Oracle of Ages/Oracle of Seasons and Minish Cap, two portable and very well regarded entries in the Zelda Franchise.

- On the Mario side, pretty much all of their Mario sport titles are handled by Camelot, with the exception of the Mario & Sonic Olympic series, which are published by Sega direcly, and their highly praised portable RPG series Mario & Luigi was developed by (sadly defunct) Alpha Dream.

- Then there was that time when they gave the Mario franchise to Ubisoft and they made a Rabbids-crossover, XCom-like game, which is just too goddamn funny to not put in here separately (especially since it was also fairly well received by critics).

- Good-Feel, another Japanese developer, made entries to both Kirby (Epic Yarn), WarioLand and more recently, Yoshi franchises (Wooly World/Crafted World).

- There is a metric shitton of Pokemon spinoffs (that's probably where you will find the worst offenders of bad outsourced games, to be quite honest, but even then there are series like Pokemon Mistery Dungeon, by Spike-Chunsoft, which are very well regarded).

- And as a another Zelda example, Cadence of Hyrule, made by the Crypt of the Necrodancer developers.

There are more examples, but overall a large part of their output nowadays is made by third-parties, with of course a lot of their projects - big and small - being handled by their in-house studios. That's not even counting the fact that some studios readily associated with Nintendo, like Intelligent Systems and HAL Laboratory, are actually independent (they just like working with Nintendo).

Sorry for the large response, I was bored.

For Java, it's probably just JNI compatibility.

I think Atom has components in C++. VSCode is Javascript only.

There isn't really anyway to monkeypatch `try` to use the operator. `try` API is inherently based on metaprogramming (passing a symbol to call), and have different semantics than the operator (by default it won't throw if a non-existent method is called in a non-nil object, while the operator will thrown a NoMethodError)

https://github.com/rails/rails/blob/4-2-stable/activesupport...