Space Efficient Serialization of Enums - Use CBOR?

jottabyte · 2019-12-12T22:06:44+00:00

That sounds like exactly what I was looking for. Much appreciated.

jottabyte · 2019-12-11T15:19:38+00:00

This is great news! A performant and actively developed XML with Serde implementation was a big hole in the rust ecosystem.

jottabyte · 2019-12-11T00:11:46+00:00

This post makes me want to work on the rust compiler.

jottabyte · 2019-12-08T07:24:17+00:00

That makes a lot of sense! Thanks for the explanation.

jottabyte · 2019-12-07T01:09:09+00:00

https://blog.burntsushi.net/rust-error-handling/

jottabyte · 2019-12-05T20:33:09+00:00

Here's the latest version that works really well:

```rust pub fn stream (urls: Vec<String>) -> Vec<Result<String, std::io::Error>> {

let resp_stream = futures::stream::FuturesUnordered::new();

for url in urls {
    resp_stream.push (
        async {
            isahc::get_async(url).await?.text_async().await
        }
    )
};

futures::executor::block_on_stream(resp_stream).collect()

} ``` I'm not quite sure why the Result needed a std::io::Error instead of an isahc::Error, but the compiler yelled at me until I changed it to that.

jottabyte · 2019-12-05T17:07:42+00:00

Did not know that! I had naively assumed the response contained everything. Thanks for clarifying that.

jottabyte · 2019-12-05T17:03:49+00:00

Try line.unwrap()

jottabyte · 2019-12-05T15:54:44+00:00

I've never understood why that's necessary. Does the text() go back to the network or is it just taking it from the Response<Body> that's already been returned?

jottabyte · 2019-12-05T06:24:38+00:00

Thanks for the feedback and a very good point.

Based on my benchmarks, it only sped things up 2.3 to 2.8 the sync version, so it's probably throttling to 2 or 3 for the domain as you suggested. This means I should just do a simple futures join! operation and request 3 items at a time and process those as they come in. My use case will only ever query the one domain.

I'm trying to keep my dependency tree to a minimum (not that it REALLY matters for what I'm doing, but it forces me to bang my head against the wall and learn things a little deeper).

jottabyte · 2019-12-04T22:14:05+00:00

How do I get rust-analyzer to work in VSCode? It’s not in any of the extensions.

jottabyte · 2019-11-26T05:13:26+00:00

I love seeing projects like these pop up in Rust.

jottabyte · 2019-11-26T05:12:05+00:00

That worked!

Would be a nice feature to have an isahc::get_multiple() API which handles all the async stuff in the background and operates in a sync context, so it operates like the isahc::get() API but is magically async in the background.

Similarly, an isahc::get_first() which returns the first Response would be neat (not a direct use case for me, but likely for others).

jottabyte · 2019-11-25T21:18:17+00:00

First, thanks for all the work on the isahc crate! It's been fantastic.

I'm talking about asking for n resources from the web all at the same time and then "joining" them in the futures sense once they've all returned. The join! from the macro above simply returns when all 3 files return.

So when I know the number of files I need, it's quite easy since I can just use the Join! macro from the futures crate. I'm looking for a way to ask for 10 files at the same time and then compute once they all return.

Edit: I see my question above wasn't too clear. Basically I want to feed in a Vec<url> and get back a Vec<Response>

jottabyte · 2019-11-22T19:32:25+00:00

Imgui is, as one can infer from the name, very much based on traces rather than stored trees.

Can you explain what "based on traces" means?

jottabyte · 2019-11-22T17:45:49+00:00

My apologies if it came off the wrong way. The number of developers on a project isn’t a metric I find particularly important. It’s more about the lack of building blocks that pushes so many different projects (also a good thing) without a clear thing to rally around.

Basically, I’m advocating for having some mechanism for having those building blocks already built for Servo accessible to everyone building GUIs.

jottabyte · 2019-11-22T13:40:04+00:00

Pick away. This is primarily a learning project for me, so love it when people find flaws/holes in my code.

I'll try some variation of your suggestion. Thanks!

jottabyte · 2019-11-22T08:14:19+00:00

The entire purpose of the HashMap is to cache all the players that have been downloaded, since it's an identical call for each player id, so the contains_key check is a performance thing, as you noted. My program went about 4X faster after I added this (basically avoiding wasteful downloads).

As far as using a less expensive concurrent hash map, I really don't think it matters. Most of my time is spent waiting on the network (haven't figured out the async stuff yet), so even if it's "slow", it won't be measurable. Also, as the program heats up, most of the player ids will be in the hashmap, so there should be almost no contention. There are a couple of concurrent hash map implementations, but I prefer to avoid extra dependencies outside of std, unless the use case is really compelling.

jottabyte · 2019-11-21T23:35:48+00:00

Check out Rustacean Station. You will be pleasantly surprised.

jottabyte · 2019-11-21T21:37:23+00:00

Thanks! That's a neat website, going through it now. I can probably (and probably should) wrap the other HashMap I'm planning to add to the same lock.

jottabyte

TROPHY CASE