0x0 | curl wrapper script to upload | Incremental Backup library

I solved the issue, though I'm still unclear on why that particular error message was showing up. Here's what I did:

I thought I might find answers in Heroku error logs on my computer. I couldn't use the heroku logs command, but I could search manually. Heroku's website says that these are located here ~/Library/Caches/heroku/error.log on macOS. But this directory didn't exist. There was no heroku folder in ~/Library/Caches/. I still had Heroku - which heroku correctly returned the path /usr/local/bin/heroku.

At this point I wondered whether the CleanMyMac X software I had used to clear storage space before updating my OS might have deleted the Heroku folder along with old error logs, and this might have prevented the program from opening?

Solution: I uninstalled the Heroku CLI based on instructions from Heroku's website:

Navigation routes are equivalent to urls. Generally you're supposed to pass something like id there.

When you need to pass a url inside another url, you need to encode it:

Here's one portable way (untested):

Using GNU awk for RT and without reading all of the input into memory at once:

Have you tried adding --platform linux/amd64 in the run command?

The WASM module uses SIMD instructions (prefixed with 0xfd, and also known as vector instructions), which were merged into the spec just last month. The latest release of wasm-decompile therefore doesn't have these enabled by default yet, but will in the next release. Meanwhile, you can enable them manually with the --enable-simd command line option. This invocation works for me with the latest release:

You have stumbled into a feature/bug in DispatchSemaphore. If you look at the stack trace and jump to the top of the stack, you'll see assembly with a message:

BUG IN CLIENT OF LIBDISPATCH: Semaphore object deallocated while in use

E.g.,

This is because DispatchSemaphore checks to see whether the semaphore’s associated value is less at deinit than at init, and if so, it fails. In short, if the value is less, libDispatch concludes that the semaphore is still being used.

This may appear to be overly conservative, as this generally happens if the client was sloppy, not because there is necessarily some serious problem. And it would be nice if it issued a meaningful exception message rather forcing us to dig through stack traces. But that is how libDispatch works, and we have to live with it.

All of that having been said, there are three possible solutions:

1. You obviously have a path of execution where you are waiting and not reaching the signal before the object is being deallocated. Change the code so that this cannot happen and your problem goes away.

2. While you should just make sure that wait and signal calls are balanced (fixing the source of the problem), you can use the approach in your question (to address the symptoms of the problem). But that deinit approach solves the problem through the use of non-local reasoning. If you change the initialization, so the value is, for example, five, you or some future programmer have to remember to also go to deinit and insert four more signal calls.

   The other approach is to instantiate the semaphore with a value of zero and then, during initialization, just signal enough times to get the value up to where you want it. Then you won’t have this problem. This keeps the resolution of the problem localized in initialization rather than trying to have to remember to adjust deinit every time you change the non-zero value during initialization.

   See https://lists.apple.com/archives/cocoa-dev/2014/Apr/msg00483.html.

3. Itai enumerated a number of reasons that one should not use semaphores at all. There are lots of other reasons, too:

   • Semaphores are incompatible with new Swift concurrency system (see Swift concurrency: Behind the scenes);
   • Semaphores can also easily introduce deadlocks if not precise in one’s code;
   • Semaphores are generally antithetical to cancellable asynchronous routines; etc.

   Nowadays, semaphores are almost always the wrong solution. If you tell us what problem you are trying to solve with the semaphore, we might be able to recommend other, better, solutions.

You said:

However, if the async function returns before deinit is called and the view controller is deinitialized, then signal() is called twice, which doesn't seem problematic. But is it safe and/or wise to do this?

Technically speaking, over-signaling does not introduce new problems, so you don't really have to worry about that. But this “just in case” over-signaling does have a hint of code smell about it. It tells you that you have cases where you are waiting but never reaching signaling, which suggests a logic error (see point 1 above).

In my case, it was the SDK not running the proper net6.0 version.

While the whole project was using new net6.0 NuGet packages, the local SDK on that one machine I was working on was still net5.0. After installing .net6.0, Swashbuckle 6.2.3 was working again, and all was as expected.