Just for reference, a few years back, (ex-Microsoft) David Plummer had this historical dive into the (MIPS) origin of the blue color, and how Windows is not blue anymore: https://youtu.be/KgqJJECQQH0?t=780

Likely due to being a prototype. Production laptops from Tuxedo tend to have the “TUX” penguin in a circle logo on the Super key by default. They also have been offering custom engraved keyboard (even with the entire keyboard engraved from scratch to the customer’s specifications) as added service, so probably there will be suppliers or production facility to change the Super key.

By the way, there was one YouTube channel that ended up ordering a laptop with Windings engraving from them: https://youtu.be/nidnvlt6lzw?t=186

How does this analogy work at all? LoRA is chosen by the modifier to be low ranked to accommodate some desktop/workstation memory constraint, not because the other weights are “very hard” to modify if you happens to have the necessary compute and I/O. The development in LoRA is also largely directed by storage reduction (hence not too many layers modified) and preservation of the generalizability (since training generalizable models is hard). The Kronecker product versions, in particular, has been first developed in the context of federated learning, and not for desktop/workstation fine-tuning (also LoRA is fully capable of modifying all weights, it is rather a technique to do it in a correlated fashion to reduce the size of the gradient update). And much development of LoRA happened in the context of otherwise fully open datasets (e.g. LAION), that are just not manageable in desktop/workstation settings.

This narrow perspective of “source” is taking away the actual usefulness of compute/training here. Datasets from e.g. LAION to Common Crawl have been available for some time, along with training code (sometimes independently reproduced) for the Imagen diffusion model or GPT. It is only when e.g. GPT-J came along that somebody invested into the compute (including how to scale it to their specific cluster) that the result became useful.

This is a very shallow analogy. Fine-tuning is rather the standard technical approach to reduce compute, even if you have access to the code and all training data. Hence there has always been a rich and established ecosystem for fine-tuning, regardless of “source.” Patching closed-source binaries is not the standard approach, since compilation is far less computational intensive than today’s large scale training.

Java byte codes are a far fetched example. JVM does assume a specific architecture that is particular to the CPU-dominant world when it was developed, and Java byte codes cannot be trivially executed (efficiently) on a GPU or FPGA, for instance.

The situation is somewhat different and nuanced. With weights there are tools for fine-tuning, LoRA/LoHa, PEFT, etc., which presents a different situation as with binaries for programs. You can see that despite e.g. LLaMA being “compiled”, others can significantly use it to make models that surpass the previous iteration (see e.g. recently WizardLM 2 in relation to LLaMA 2). Weights are also to a much larger degree architecturally independent than binaries (you can usually cross train/inference on GPU, Google TPU, Cerebras WSE, etc. with the same weights).

There is even a sentence in README.md that makes it explicit:

The source files in this repo are for historical reference and will be kept static, so please don’t send Pull Requests suggesting any modifications to the source files […]

Have people actually checked the versions there before making the suggestion?

F-Droid: Version 3.5.4 (13050408) suggested Added on Feb 23, 2023
Google Play: Updated on Aug 27, 2023

https://f-droid.org/en/packages/org.videolan.vlc/
https://play.google.com/store/apps/details?id=org.videolan.vlc

The problem seems to be squarely with VLC themselves.

It is like the U.S. Wired catching up to the idea years later?

See to the right:

Here you may post anything related to DeGoogling, why we should do it or good software alternatives!

Retention, or the lack thereof, when cold-stored.

In term of SD or standard NAND, not even Nintendo does that. Nintendo builds Macronix XtraROM in their Game Card, which is some proprietary Flash memory with claimed 20 year cold storage retention. And they introduced the 64 GB version only after a lengthy delay, in 2020. So it seems that the (lack of) cold storage performance of standard NAND Flash is viewed by some in the industry as not ready for prime time. Macronix discussed it many years back in a DigiTimes article: https://www.digitimes.com/news/a20120713PR201.html.

And Sony and Microsoft are both still building Blu-ray-based consoles.

https://fosstodon.org/@jimsalter/110441094176772187

Yes. But one should also note that only a limited range of Intel GPU support SR-IOV.

FSFE’s statement:

• https://fsfe.org/news/2023/news-20231011-01.en.html

Some related personal blogs I noticed:

• https://ebb.org/bkuhn/blog/2023/10/11/moglen-sflc.html
• https://mjg59.dreamwidth.org/68004.html

What you suggested cannot be further from the truth. The paper that got her the Nobel was from 2005 (https://www.cell.com/immunity/fulltext/S1074-7613(05)00211-6, see also cited in https://www.nobelprize.org/prizes/medicine/2023/press-release/), and UPenn claimed in 2013 — at least 7 years later — that she would not be “of faculty quality” (https://www.wired.co.uk/article/mrna-coronavirus-vaccine-pfizer-biontech).

You know, there are several built-in functions in phones, that are already viable methods to communicate remotely?

The novel bit of this project is actually the usage of GGML quantization from llama.cpp for Stable Diffusion, which can offer lower RAM usage and faster inference on CPU than all the previous CPU implementations without the benefit of low bit quantization, which was known to make CPU and low RAM LLaMA inference feasible.

The important long term implication is that people have been targeting the incorrectly sized Stable Diffusion model, if the goal is quality on commodity hardware (this includes GPU, too). For example, Stable Diffusion where Stability AI has gloated so much how it fits commodity hardware is slightly less than 1 billion parameters. The smallest LLaMA that people nowadays can happily run on commodity GPU or CPU is already 7 billion parameters. And even OpenAI’s DALL·E 2, which many called prohibitive because “you need a 48 GB GPU” (which is not true, with quantization), is just 3.5 billion parameters.

For additional context, Stable Diffusion using CPU has been done before, though with repurposed frameworks rather than a custom C++ project. Notably, there has been a Q-Diffusion paper (https://github.com/Xiuyu-Li/q-diffusion), but the result was obtained by simulating the quantization, and e.g. the GitHub repo not actually offer an implementation with actual speed-up.

• People who had math in high school and have seen blackboard bold/double struck characters

GCC, back in the days DJGPP in particular. As a child in the 1990s I could not afford the big name compilers like Watcom. And compared to DJGPP, all the “prized” Borland/Turbo stuff that my middle school pushed (with segmented real mode), were practically Fisher-Price and Mattel compilers.