share | mycode

Why do I name projects with a website in the path?

If your package has the exact same import path as someone else's package, then someone will have a hard time trying to use both packages in the same project because the import paths are not unique. So long as everyone uses a string equal to a URL that they effectively "own", such as your GitHub account (or actually own, such as your own domain), then these name collisions will not occur (excepting the fact that ownership of URLs may change over time).

It also makes it easier to go get your project, since the host location is part of the import string. Every source file that uses the package also tells you where to get it from. That is a nice property to have.

Where do I initialize git?

Your project should have some root folder that contains everything in the project, and nothing outside of the project. Initialize git in this directory. It's also common to initialize your Go module here, if it's a Go project.

You may be restricted on where to put the git root by where you're trying to host the code. For example, if hosting on GitHub, all of the code you push has to go inside a repository. This means that you can put your git root in a higher directory that contains all your repositories, but there's no way (that I know of) to actually push this to the remote. Remember that your local file system is not the same as the remote host's. You may have a local folder called github.com/myname/, but that doesn't mean that the remote end supports writing files to such a location.

There is a difference between a file and a file descriptor (FD).

All processes share the same files. They don't necessarily have access to the same files, and a file is not its name, either; two different processes which open the same name might not actually open the same file, for example if the first file were renamed or unlinked and a new file were associated with the name. But if they do open the same file, it's necessarily shared, and changes will be mutually visible.

But a file descriptor is not a file. It refers to a file (not a filename, see above), but it also contains other information, including a file position used for and updated by calls to read and write. (You can use "positioned" read and write, pread and pwrite, if you don't want to use the position in the FD.) File descriptors are shared between parent and child processes, and so the file position in the FD is also shared.

Another thing stored in the file descriptor (in the kernel, where user processes can't get at it) is the list of permitted actions (on Unix, read, write, and/or execute, and possibly others). Permissions are stored in the file directory, not in the file itself, and the requested permissions are copied into the file descriptor when the file is opened (if the permissions are available.) It's possible for a child process to have a different user or group than the parent, particularly if the parent is started with augmented permissions but drops them before spawning the child. A file descriptor for a file opened in this manner still has the same permissions uf it is shared with a child, even if the child would itself be able to open the file.

It completely depends on what your listener is doing with the data.

If it processes each record in a loop then there is no benefit; you might as well just let the container iterate over the collection and send the listener one record at-a-time.

Batch mode will improve performance if you are processing the batch as a whole - e.g. a batch insert using JDBC in a single transaction.

This will often run much faster than storing one record at-a-time (using a new transaction for each record) because it requires fewer round trips to the DB server.

We reshape the data into 'long' format with pivot_longer, then we group by 'ID' and loop across the other columns, apply the na.omit to remove the NA elements (we assume that there is only one non-NA per each column by group)

In the first place you are probably getting an AttributeError error that append is not known. Because you try to append your text to the TextIOwrapper (feeds speeds). You have to use the write method to append the text to the file content.

Also note that your file is read and written from the current directory, so ./feedsspeeds.txt. As long as you are not executing this script from you Desktop folder, the file will also not be written there.

Update:

I added the following code to refresh the core data before I fetch. Everything work as expect.

It varies between implementations, but generally, this is managed by the cache coherency protocol of the multiprocessor. In simplest terms, what happens is that when CPU1 writes to a memory location, that location will be invalidated in every other cache in the system. So that write will invalidate the line in CPU2's instruction cache as well as any (partially) decoded instructions in CPU2's uop cache (if it has such a thing). So when CPU2 goes to fetch/execute the next instruction, all those caches will miss and it will stall while things are refetched. Depending on the cache coherency protocol, that may involve waiting for the write to get to memory, or may fetch the modified data directly from CPU1's dcache, or things might go via some shared cache.

As you manually use the loss and metrics function in the train_step (not in the .compile) for the training set, you should also do the same for the validation set or by defining the test_step in the custom model in order to get the loss score and metrics score. Add the following function to your custom model.

What is happening in your code:

You have an object coord. You are pushing its reference to the array, in each iteration. All your array elements point to coord. You are changing the properties of the object coord again in turn changing your array elements.