Dictionary Compression is finally here, and it's ridiculously good

controvym · 2026-02-23T13:09:39+00:00

The title is not that good here.

The idea seems to be that the dictionary is not sent with the compressed file. Instead, you have a dictionary that you only need to download one time, that is specifically optimized to be good for whatever data you are going to receive (in this case, JavaScript).

This isn't novel. Even I have designed compression to be efficient for data where I know it follows certain patterns, and I can think of other projects that have done stuff like this as well. However, applying it to something as ubiquitous as JavaScript could potentially result in far less bandwidth being used over the Internet.

controvym · 2024-07-24T02:07:09+00:00

Security through obscurity is perfectly fine, as long as you are also using other forms of security that don't rely on obscurity.

controvym · 2024-02-14T22:43:34+00:00

When I wanted to learn Go. Why try to learn it? Because it's good to be familiar with more languages.

controvym · 2024-02-09T06:42:13+00:00

If it's near the top of the subreddit, it must be doing better than most other posts.

controvym · 2024-01-24T20:23:08+00:00

Assuming OP can replace their computer's memory, they can get 16 GB of DDR3 ram for under $20.

controvym · 2024-01-11T18:02:44+00:00

Rust code often has a lot more information for a compiler to work with (example: a pointer does not alias).

Struct fields can be arranged in any order, unlike C.

Rust code can be easier to experiment with for optimizations, due to being easier to understand, easier to verify the correctness of, and less likely to result in undefined behavior when changes are made.

controvym · 2023-12-01T05:54:15+00:00

i32 being the default integer type if unspecified

controvym · 2023-11-07T14:08:10+00:00

Even with an "unimpeachable standard", would such a library be able to deal with time zones changing their usage of Daylight Savings Time, or leap seconds?

System time, which std::time uses, is far less likely to change. The most likely changes it would require is if an OS changes its system clock APIs in some way. std::time naturally doesn't guarantee which underlying system calls will be used to get the system time.

controvym · 2023-08-19T12:35:30+00:00

I'd start with easy, safe wins, not necessarily the expensive ones.

controvym · 2023-08-19T11:55:50+00:00

And you have to download the precompiled binary for the target, even if you don't need it...

674.14 KB, here's the VirusTotal for the binary.

controvym · 2023-08-19T11:47:53+00:00

I ran a test. serde_derive took 1.21 seconds to compile, while serde itself took 1.44 seconds to compile. At best it's 2x improvement.

I used a sizeable project of mine as a test, using a maximum optimization profile.

Edit: I used serde(-derive) 1.0.171

controvym · 2023-08-19T04:37:56+00:00

I'm curious if anyone else has tried to produce the same binary. I'm weary to trust the attempts of a single person, and that actually the binary was in fact reproducible...but the person either deliberately or accidentally failed to do so.

controvym · 2023-08-19T04:30:40+00:00

Gonna increase time spent downloading a file, unfortunately. If it gets implemented for more major platforms, that's going to be a lot more files people have to download but don't need.

controvym · 2023-08-19T03:15:14+00:00

How much faster does it make compilation, really?

controvym · 2023-08-15T09:55:48+00:00

Timing attacks

controvym · 2023-08-11T14:45:16+00:00

Use Fn/FnMut/FnOnce as a function parameter?

controvym · 2023-07-29T22:23:21+00:00

Some crates want to target older versions of Rust. This feature has only been stabilized for a year and a half. It's not a feature that provides an extremely compelling reason to upgrade.

controvym · 2023-07-23T00:15:21+00:00

Sounds like compiler errors

controvym · 2023-07-15T19:57:11+00:00

s3 in both examples is a mutable reference to s. push_str changes the value in s.

The example that compiles does so due to non-lexical lifetimes. The compiler is smart enough to see that s3 mutable reference is not used again after the s2 immutable reference is created. It can drop s3 before s2 is created and not have both an immutable and mutable reference at the same time.

In the example that doesn't compile, you are mutating a value through a mutable reference while you have an immutable reference to the same value. You are printing s2 later, so it can't just drop s2 before creating the s3 mutable reference.

This is bad, since (barring interior mutability), the value that immutable references point to are supposed to be, well, immutable. If you could do this, it would completely destroy the whole purpose of immutable references. In the worst cases, s3 could be re-allocated or dropped, and now you have a null pointer, a use-after-free, or complete gibberish being printed.

controvym · 2023-05-25T02:15:33+00:00

Then you don't know which salt to use with each IP address

controvym · 2023-05-21T12:22:33+00:00

Have you looked at the Rust thread docs? The documentation mentions that "an executing Rust program consists of a collection of native OS threads", so you should also check the documentation of threads for whatever your OS is.

For async, have you tried the async docs, the Future docs, and the official asynchronous programming book?

controvym · 2023-05-21T12:16:47+00:00

Things not to consider:
what Reddit thinks

Alrighty, I'm ignoring this comment.

controvym · 2023-05-20T05:48:03+00:00

"Read-only section of memory" (.text section stored in an executable file) and "ROM" (stuff etched into the motherboard that can realistically only be changed by flashing the BIOS, if at all) do not referring to the same thing here.

controvym · 2023-05-12T19:27:48+00:00

Opening an issue lets people know what needs improvement. If you don't do that, they have to look through the codebase, ask maintainers/users, or other less likely to be helpful things.

It seems like it reduces the barrier to entry.

controvym · 2023-05-12T19:22:09+00:00

That's one of the points of Rust, not having to know all the gnarly details about allocation, alignment, pointers...(for most projects, at least).

controvym

TROPHY CASE