unWrap | Unwrap allsky images into rectilinear in Python | Computer Vision library

I think your dispose method is correct because TryComplete returns true only once and it is thread safe.

But there is a problem, you expose the channel to subscribers, so they are able to explicitly call TryComplete/Complete to finish the writer. It's better to conceal it and just expose a write method.

Edit: Upgrading to sha256 = "1.0.3" should fix this

The issue is that digest_file is internally reading the file to a String, which requires that it contains valid UTF-8, which is obviously not what you want in this case.

Instead, you could read the file in as bytes and pass that into sha256::digest_bytes:

The issue is one of scoping and an implementation detail of rodio: the one critical item here is OutputStream::try_default(), it doesn't really matter how you handle Sink::try_new(&handle) it'll always behave the same, not so try_default, if you match or if let it it'll work fine, if you unwrap it it'll fail.

But why would that be, the two should be equivalent. The answer is in the details of rodio, specifically of OutputStreamHandle:

Rust doesn't know that your strings will last as long as your threads, so it won't pass a reference to them to the threads. Imagine if you passed a reference to a string to another thread, then the original thread thought it was done with that string and freed its memory. That would cause undefined behavior. Rust prevents this by requiring that the strings either be kept behind a reference-counted pointer (ensuring their memory doesn't get freed while they are still referenced somewhere) or that they have a 'static lifetime, meaning they are stored in the executable binary itself.

Also, Rust won't allow you to share a mutable reference across threads because it is unsafe (multiple threads could try to alter the referenced data at once). You want to use an std::sync::Arc in conjunction with a std::sync::Mutex. Your strings vector would become a Vec>>. Then, you could copy the Arc (using .clone()) and send that across threads. Arc is a pointer that keeps a reference count that gets incremented atomically (read: in a thread-safe way). The mutex allows a thread to lock the string temporarily so other threads can't touch it then unlock the string later (the thread can safely change the string while it is locked).

Your code would look something like this:

I would propose to take a look in the RateLimiter direction. Maybe it does not work as expected, depending on the number of requests your application does over time. From the Javadoc for Ratelimiter: "It is important to note that the number of permits requested never affects the throttling of the request itself ... but it affects the throttling of the next request. I.e., if an expensive task arrives at an idle RateLimiter, it will be granted immediately, but it is the next request that will experience extra throttling, thus paying for the cost of the expensive task." Also helpful might be this discussion: github or github

I could imaginge there is some throttling adding up or other effect in the RateLimiter, i would try to play around with it and make sure this thing really works the way you want. Alternatively, consider using Spring @Scheduled to read from your queue. You might want to spice it up using embedded JMS for further goodies (message persistence etc).

The problem is here:

The issue you're going to have to confront is how to deal with function calls. I can't really give you any concrete advice based on your question, because the grammar you provide lacks any indication of the intended syntax of functions calls, but the hint that print(5) is a valid statement makes it clear that there are two distinct situations, which need to be handled separately.

Consider:

The problem here is that if you remove your Var from the shared variable, what would be left there? What happens if any other copy of your Arc is left somewhere and it tries to access the now removed object?

There are several possible answers to that question:

If that is the case, you can use Arc::try_unwrap() to get to the inner mutex. Then another into_inner() to get the real value.

The answer is that you are likely not doing anything wrong. Essentially, WASM has the potential to be faster, but will not always be faster.

I really liked this quick read from Winston Chen in which they run performance testing comparing web assembly to vanilla JS.

If you're interested in more in-depth conversation, this talk by Surma at Google I/O '19 is very informative. From the video:

Both JavaScript and Web Assembly have the same peak performance. They are equally fast. But it is much easier to stay on the fast path with Web Assembly than it is with JavaScript.