Sup | A Slack client with WhatsApp like UI | Chat library

So I was really ripping my hair out why two different sessions of R with the same data were producing wildly different times to complete the same task. After a lot of restarting R, cleaning out all my variables, and really running a clean R, I found the issue: the new data structure provided by vroom and readr is, for some reason, super sluggish on my script. Of course the easiest thing to solve this is to convert your data into a tibble as soon as you load it in. Or is there some other explanation, like poor coding praxis in my functions that can explain the sluggish behavior? Or, is this a bug with recent updates of these packages? If so and if someone is more experienced with reporting bugs to tidyverse, then here is a repex showing the behavior cause I feel that this is out of my ballpark.

I want a function that takes two arguments, both of which can be turned into an iterator of Foo. The snag is that I'd like to accept things which are both IntoIterator and also IntoIterator<&Foo>. Importantly Foo is Copy so I can cheaply create an owned copy from it's reference.

The solution I currently have is:

I'm new to gganimate and was having difficulty figuring out how to do this.

I'd like to show the spread in two different levels of a variable by animating colour transitions. I want to show this by having the narrow level transition through a smaller range of colours than the wider level in the same amount of time. Is this possible?

Here's the reproducible example I have up-to now.

My Issue: Please help me run this code as it should. I am getting a null form error when typing a City name in the place holder and I'm not sure why I am practicing this code from here: https://webdesign.tutsplus.com/tutorials/build-a-simple-weather-app-with-vanilla-javascript--cms-33893

As I understand, when compiling a compilation unit, the compiler's preprocessor translates #include directives by expanding the contents of the header file¹ specified between the < and > (or ") tokens into the current compilation unit.

It is also my understanding, that most compilers support the #pragma once directive guarding against multiply defined symbols as a result of multiple inclusion of the same header. The same effect can be produced by following the include guard idiom.

My question is two-fold:

1. Is it legal for a compiler to completely ignore an #include directive if it has previously encountered a #pragma once directive or include guard pattern in this header?
2. Specifically with Microsoft' compiler is there any difference in this regard whether a header contains a #pragma once directive or an include guard pattern? The documentation suggests that they are handled the same, though some user feels very strongly that I am wrong, so I am confused and want clarification.

¹ I'm glossing over the fact, that headers need not necessarily be files altogether.

I would like to read a GRIB file downloaded from server using ecCodes library in Rust. However, my current solution results in segmentation fault. The extracted example, replicating the problem, is below.

I download the file using reqwest crate and get the response as Bytes¹ using bytes(). To read the file with ecCodes I need to create a codes_handle using codes_grib_handle_new_from_file()², which as argument requires *FILE usually get from fopen(). However, I would like to skip IO operations. So I figured I could use libc::fmemopen() to get *FILE from Bytes. But when I pass the *mut FILE from fmemopen() to codes_grib_handle_new_from_file() segmentation fault occurs.

I suspect the issue is when I get from Bytes a *mut c_void required by fmemopen(). I figured I can do this like that:

What Every Computer Scientist Should Know About Floating-Point Arithmetic makes the following claim:

Due to roundoff errors, the associative laws of algebra do not necessarily hold for floating-point numbers. For example, the expression (x+y)+z has a totally different answer than x+(y+z) when x = 10³⁰, y = -10³⁰ and z = 1 (it is 1 in the former case, 0 in the latter).

How does one reach the conclusion in their example? That is, that (x+y)+z=1 and x+(y+z)=0?

I am aware of the associative laws of algebra, but I do not see the issue in this case. To my mind, both x and y will overflow and therefore both have an integer value that is incorrect but nonetheless in range. As x and y will then be integers, they should add as if associativity applies.

I have a panda dataframe like this:

I just noticed that read_csv() somehow uses random numbers which is unexpected (at least to me). The corresponding base R function read.csv() does not do that. So, what does read_csv() use the random numbers for? I looked into the documentation but could not find a clear answer to that. Are the random numbers related to the guess_max argument?