samus

It could simply be diluted with lots of river water and disposed into the sea, like the waste product of saltwater desalination plants.

Another solution would be to test it in a lab and then bottle it up and sell it, like it was originally intended to be done. But that's a non-starter for the same reason the producer went out of business back then.

Yes, it needs to be handled with care, but it's essentially the same procedure as with the waste products of desalination water plants. One caveat though - once you start diluting this stuff you have to keep going since the high salt content is the only thing that ensures it's fairly sterile.

Acid is a good way to modulate the flavor. There is a reason why in Vietnamese dishes are often served with limes.

Teaching only the practical side risks not teaching the subject with the appropriate theoretical depth and the ability to generalize it to other applications. Courses for purely applied fields utilize calculus to solve the current problem and then move on without teaching the finer points. Basing a calculus course on physics alone might be preferable in high school, but would be of disservice to students in university.

Even when this really isn't the case, the math is preferably reduced to a linear problem whenever possible since dealing with the original complexity is usually so much more painful.

Many important advances in linear algebra happened in WWI to solve optimization problems for logistical and industrial planning. A lot of these applications boil down to high-dimensional systems of linear equations, which back then were solved by hand. Efficient algorithms translate to reduced labor costs.

The ultimate goal of university education is to raise researchers, who are the people that investigate the knowledge frontier of their field and then advancing it. To do that they have to understand a large part of the existing field so they can communicate with their peers, avoid investigating things that have already been throroughly explored, and draw useful connections to other fields.

Even in more applied fields it can take decades before advances become practically relevant. Restricting teaching to topics that have immediate practical relevance would therefore do students a huge disservice and prevent them from approaching the knowledge frontier of the field.

There is a tension between applied and theoretical mathematics, and it's as old as the whole science itself. Mathematics arose to solve practical problems (land surveying and division, as well as trade) and recognizing the underlying principles make it possible to abstract that knowledge. That might lead to centuries of ivory tower activity and what could be regarded as a purely artistic pursuit until somebody figures out how to apply a theory to a new practical problem. Or relations to another theory are discovered, and suddenly there is a new approach to previously intractable questions. A good example is be number theory, which is the foundation of modern cryptography.

It's a good outcome as long as the proof is valid and ubderstandable to humans and leads to the discovery of further knowledge. There has been decades of search in Theorem Proving; this is just the next step.

The official guidance is very simple and straightforward: upgrade regularly and keep eyes open for the few actual things that could cause trouble. If a project cannot keep up it can always stick to LTS versions. That's it.

Just one more push to Java 17; from there on it should be smooth sailing. I hope you have built up a comprehensive regression test suite as part of the migration.

Patches are released continuously. The upstream versions get them immediately and they are then backported to LTS versions. Whether the patches actually become available simultaneously I cannot say without.

Yes, you can. There is no need to recompile, unless you're interested in new language features.

Maintaining binary compatibility is a principal goal of the platform which continues to constrain design decisions for all future changes.

I believe that's by design: applications are encouraged to upgrade often. That's usually a smooth process for standard-conforming applications.

Applications that need to move slower can stick to LTS versions. LTS hopping has become a little bit more viable since the interval has been shortened to two years, i.e., four major versions.

Presumably by targeting them toward these differences.

Since the presence of that chromosome causes problems in an organism that functions normally with just two of these chromosomes, the change is actually not that big. And the therapy might also not be intended for adults or even children - most of the developmental impediments have already happened at that stage, and neither cutting out the extra chromosome or silencing it will fix this up.

How about kobold.cpp then? Or LMStudio (I know it's not open source, but at least they give proper credit to llama.cpp)?

Re curation: they should strive to not integrate broken support for models and avoid uploading broken GGUFs.

Getting an overview of parsing theory is mainly useful to avoid making ambiguous or otherwise hard to parse grammars. Usually one can't go too wrong with a hand-written recursive descent parser, and most general-purpose language are so complicated that parser generator can't really handle them. Anyway the really interesting parts of compiling happen in the backend.

Another alternative is basing the language on S-expressions, for which a parser is extremely simple to write.

Single transistors aren't yet logic gates by themselves; they are amplifiers with a very specific gain function that makes it possible to use them as switches. Logic gates usually consist of at least two transistors. See https://en.wikipedia.org/wiki/CMOS for an example of how it is done in CMOS technology.

I was referring to that model :-)

We don't just use one single method to infer distances. TA is about that there are multiple methods, and that the framework is open for new ones. What is more likely at fault is the underlying model of how the cosmos developed, which is highly likely to be incomplete or misguided.

It's just the sin with the greatest consequences since it invokes the wrath of the groups the person being killed belonged to. Unlawful killings challenge the authority of those who determine which killings are lawful and which aren't, therefore destabilizing societies that are more complex than a hunter-gatherer group.

However, most religions do more than just declare murder to be a sin. They usually aim to foster bonds between relative strangers as well. And values like the guest-host relationship are held to apply to all humans and even to sentient non-humans.

There is one very serious issue with software: it needs updates for security issues that are uncovered. And it might be built requiring access to MS cloud services to work. To get rid of these problems is basically equivalent to adopting open source products.

At the same time, TFA is about software, not about the computers themselves.

At the same time it is an open source product and can therefore be forked. Being controlled by Google presents not nearly such an issue as Microsoft products or the Apple ecosystem.

Android Open Source is good enough. The tough part are device-specific drivers that never make it upstream and are eventually abandoned by the vendor, making upgrade past specific kernel versions very troublesome.

Which powerful computers are made in the USA? Design and assembly don't count, as these are the least robust to replication attempts. Apart from that, the manufacturing is all in East Asia; Intel is the exception, not the normal!

Achieving redundancy from China is likely not possible in the near future. Meanwhile, the risk emanating from a rugpull or from deliberate sabotage by the USA is very concrete.

None of these devices are mission-critical. Worst case they have to be restarted; then they are fine again and the world moves on.

Unshielded circuits are basically radiation detectors. Even here on planet Earth bitflips are an underappreciated source of unreproducible bugs.

A bit flip in an index variable, a pointers or in native code can send the CPU on a wild goose chase around memory.

To add insult to injury, applications like browsers use JITs, which generate and execute large amounts of native code on the fly, making them even more vulnerable for this kind of fault.

The same issue arises from overclocking, inconsistent power sources, and from damaged RAM cells, but those problem sources can presumably be dismissed on a vehicle with pristine, well-made hardware during a short hop to the moon and back.

https://news.ycombinator.com/item?id=47252971