libcxx | Project moved to https

I have miniconda installed on my mac os 10.13.6 and I want to install PyPy3.7 in the same conda environment where I already have installed Python3.9. However, when I try to install PyPy I get the following dependency errors.

This question appears to have been answered before, but none of the answers helped in my case. First I should say that I've followed the OSMnx Installation steps exactly. Then tried to run the following code in a Jupyter Notebook:

Move operations should be noexcept; in the first place for intuitive and reasonable semantics. The second argument is runtime performance. From the Core Guidelines, C.66, "Make move operations noexcept":

A throwing move violates most people’s reasonably assumptions. A non-throwing move will be used more efficiently by standard-library and language facilities.

The canonical example for the performance-part of this guideline is the case when std::vector::push_back or friends need to grow the buffer. The standard requires a strong exception guarantee here, and this can only move-construct the elements into the new buffer if this is noexcept - otherwise, it must be copied. I get that, and the difference is visible in benchmarks.

However, apart from this, I have a hard time finding real-world evidence of the positive performance impact of noexcept move semantics. Skimming through the standard library (libcxx + grep), we see that std::move_if_noexcept exists, but it's almost not used within the library itself. Similarly, std::is_noexcept_swappable is merely used for fleshing out conditional noexcept qualifiers. This doesn't match existing claims, for example this one from "C++ High Performance" by Andrist and Sehr (2nd ed., p. 153):

All algorithms use std::swap() and std::move() when moving elements around, but only if the move constructor and move assignment are marked noexcept. Therefore, it is important to have these implemented for heavy objects when using algorithms. If they are not available and exception free, the elements will be copied instead.

To break my question into pieces:

1. Are there code paths in the standard library similar to the std::vector::push_back, that run faster when fed with std::is_nothrow_move_constructible types?
2. Am I correct to conclude that the cited paragraph from the book is not correct?
3. Is there an obvious example for when the compiler will reliably generate more runtime-efficient code when a type adheres to the noexcept guideline?

I know the third one might be a bit blurry. But if someone could come up with a simple example, this would be great.

All of my virtual environments work fine, except for one in which the jupyter notebook won't connect for kernel. This environment has Zipline in it, so I expect there is some dependency that is a problem there, even though I installed all packages with Conda.

I've read the question and answers here, and unfortunately downgrading tornado to 5.1.1 didn't work nor do I get ValueErrors. I am, however, getting an AssertionError that appears related to the Class NSProcessInfo.

I'm on an M1 Mac. Log from terminal showing the error below, and my environment file is below that. Can someone help me get this kernel working? Thank you!

I am developing on macOS with Apple-clang v12 being the default compiler via the Xcode installation. Since valgrind still does not support Big Sur and the Apple version does not support Google Sanitizers I have to manually install llvm v11.1 via homebrew to leverage Google Sanitizers to have any memory leak detection tool enabled.

Unfortunately this causes some issues with conan and its integration with CMake and CLion, my IDE. Since my dependencies do not provide binaries for my architecture using clang instead of Apple-clang they have to built locally. Unfortunately conan and CMake error when invoking them with two contradictory error messages:

I'm running Ubuntu 20.04 and I have installed libc++-dev (and ABI) package which is libc++-6.0-2.

However, now I have to use CLang 11, which requires a newer version of libc++ for better support to C++17, so I need to install libc++-11-dev, which is a different package and will replace my older.

My question is, how do I know if libc++ is backward compatible? I have hundreds of projects built and I don't want to rebuild all again.

I can't find a clear information about it in libcxx-11 documentation.

While making a project compile across both GCC and Clang, I've noticed that functions like fabs were causing compilation issues on GCC, since I had never included myself. I was developing on Clang, so I never noticed this, since the llvm header file I was using includes itself, seemingly without doing anything with it, while the GCC version does not.

Is there any reason for this? and is there anything I can do to make sure my code will compile across multiple standard libraries besides just trying it?

I'm trying to compile a relatively simple C++ program using emscripten for use in javascript (wasm). When I compile with the following settings

Running the command: