edflsafoiewq

Why is Direct2D so hard to implement in Wine?

General theme: A programming language's native in-memory object format is typically optimized for random access, uniformity, and mutability (fields at fixed offsets, etc). Serialization formats for network or disk tend to be designed explicitly to be more compact. But you can design your own in-memory representation too, with the properties you need.

Oh is that why the page is like 50 megs.

That is the opposite of what GP said. The point is only the total emissions matter, the climate does not care about "fair" allocations over either people or nation-states.

Sounds like it would be easier to hope for a better UPI experience for tourists.

1. The output is a permutation of the input.

2. If the comparison implements a strict total order, the output is sorted according to it.

The DCs giving you a 1/8 downscale is well known, but the interesting part to me was this generalizes so you can get 1/4 (resp. 1/2) downscales by using only the 2x2 (resp. 4x4) block of LF coefficients.

> Modular found ways to parralize LLVM code generation by introducing novel techniques

What techniques?

There is already Invoke-WebRequest. Powershell 5 infamously shipped with "curl" as an alias for it. So be careful what you wish for.

I interpreted that to mean "other people should be working because it will enable me personally to buy more stuff (that they produce)", not "each person should be working because working will allow that person to buy themselves more stuff".

This was added in 3.14. The zipfile module was updated too, which probably makes Python the easiest way to work with ZIP files with zstd compression.

You can't use BigDecimal either. There are libraries whose whole purpose is just to exactly reproduce COBOL arithmetic, eg. the IBM Decimal Arithmetic Library.

"Porcupine" confused with "concubine".

"You could have invented..." a just a genre of expository writing which builds a path from something you know to something you want to learn. The sequence of development is not necessarily even historically accurate, it can be completely invented as long as the learner finds it natural and it helps motivate them.

The fact that invention is hard and actually you probably couldn't have invented a bunch of hard stuff is not really that, um, relevant.

The big labs don't generally have the resources to remove stuff and re-run training again either. That's reserved for new models. Existing models are modified by operating on the weights even by the model creators, which exactly satisfies the GPL's definition of source as the "preferred form for making modifications".

PrismML released a ternary model recently. However AFAICT they don't use this packing, instead packing trits as 2 bits each (as least for the GGUF).

Hy-MT2 also came out with a 1.25bit model using a technique called Sherry, where weights are trits with the additional constraint that exactly one trit in a group of four is 0. Four possible positions for the 0 times 2^3 possibility for the other three positions = 32 possibilities, so it fits in 5 bits exactly. You can also exploit the sign symmetry by factoring out a sign bit and you have sixteen possibilities for a group where the first non-zero trit is +1. Unpacking can then be done with a 16 bytes lookup table, which is small enough to do really fast with SIMD.

I actually don't think LLMs are "really" intelligent either, but we do seem to be pawing our way towards something. Everyone is talking about safety and risk and alignment. But I never read anything about what kind of moral obligations we might have towards our hypothetical AI children.

People swear up and down these things are real intelligences and not stochastic parrots until the ethical questions come out and then they're just fancy washing machines.

What's the advantage of the separate streams? That presumably prevents a streaming encoder/decoder.

It appears they are using Q2_0 in llama.cpp, which is 2 bits per weight + 1 float16 scale per group of 64 weights. This is inefficient in two ways: one bit pattern is wasted on each weight, since ternary weights only use {-1,0,1} and Q2_0 allows {-1,0,1,2}; and their group size is 128 weights, so the scale will be stored twice in two groups of 64 instead of stored only once in one group of 128.

Their fork corrects the second inefficiency by using a group size of 128, but still uses 2-bit weights AFAICT.

It's possible to pack 5 trits into a byte, but the unpacking is not very efficient. Another recent idea is to add the constraint that exactly one weight in each group of four be zero, which gives exactly 32 possible states, so it fits in 5 bits.

I find it kind of interesting the whole output wasn't released. A common criticism of mathematical writing is results are "pulled out of a hat"; you only write up a polished, final proof, but hide everything that went into developing it. It's kind of ironic the practice is even carried on when an LLM writes the proof.

In data structure terms, attributes do allow nodes to be decorated with additional information without forcing any change on existing parsers. In JSON, this would require swapping, eg. "str" -> {"value": "str", "attrib1": "..."}.

I think those are CLI options, not negative signs. Ie. you call zstd -3 for compression level 3.

"Oh gee, we'd definitely contribute to the open source driver if the repo name didn't have wacom in it." Yeah, uh huh.

It's typical to only append fields when you do this.

> I'm not going to name those countries outright

Why?

That isn't because of a general opposition to all uses of Latin.

The regulation targets most portable electronics, not just phones.

I understand why coroutines are an issue for saving, but why are they an issue for pausing? Don't you just not resume the coroutines while paused?

Oh brave new world, that has such arguments in it!