o-share | URL and social media | Social Channel Utils library

Third option: don't move the file data through your app at all. Have the user upload it directly to object storage. This usually means making an API which returns a pre-signed upload URL that's valid for a few minutes, user uploads the file, then makes another call to let you know the upload is finished. Then your async task can download it and do whatever.

Otherwise you have the two options correctly. For option 2, and internal Minio server is pretty common since again, Django is very slow for serving large file blobs.

This is covered in section 6.9/5 of the latest C Standard:

Semantics

An external definition is an external declaration that is also a definition of a function (other than an inline definition) or an object. If an identifier declared with external linkage is used in an expression (other than as part of the operand of a sizeof or _Alignof operator whose result is an integer constant), somewhere in the entire program there shall be exactly one external definition for the identifier; otherwise, there shall be no more than one.

The term "external definition" should not be confused with "external linkage" or the extern keyword, those are are entirely different concepts that happen to have similar spelling.

"external definition" means a definition that is not tentative, and not inside a function.

Regarding tentative definition, ths is covered by 6.9.2/2:

A declaration of an identifier for an object that has file scope without an initializer, and without a storage-class specifier or with the storage-class specifier static , constitutes a tentative definition. If a translation unit contains one or more tentative definitions for an identifier, and the translation unit contains no external definition for that identifier, then the behavior is exactly as if the translation unit contains a file scope declaration of that identifier, with the composite type as of the end of the translation unit, with an initializer equal to 0.

So in your file 1.c, as per 6.9.2/2 the behaviour is exactly as if it had said int i = 0; instead. Which would be an external definition. This means 0.c and 1.c both behave as if they had external definitions which violates the rule 6.9/5 saying there shall be no more than one external definition.

Violating a semantic rule means the behaviour is undefined with no diagnostic required.

See also: Undefined, unspecified and implementation-defined behavior

In case it is unclear, the C Standard saying "the behaviour is undefined" means that the C Standard does not define the behaviour. The same code built on different conforming implementations (or rebuilt on the same conforming implementation) may behave differently, including rejecting the program , accepting it, or any other outcome you might imagine.

(Note - some programs can have the defined-ness of their behaviour depend on runtime conditions; those programs cannot be rejected at compile-time and must behave as specified unless the condition occurs that causes the behaviour to be undefined. But that does not apply to the program in this question since all possible executions would encounter the violation of 6.9/5).

Compiler vendors may or may not provide stable and/or documented behaviour for cases where the C Standard does not define the behaviour.

For the code in your question it is common (ha ha) for compiler vendors to provide reliable behaviour ; this is documented in a non-normative Annex J.5.11 to the Standard:

J.5 Common extensions

J.5.11 Multiple external definitions 1 There may be more than one external definition for the identifier of an object, with or without the explicit use of the keyword extern ; if the definitions disagree, or more than one is initialized, the behavior is undefined (6.9.2).

It seems the gcc compiler implements this extension if -fcommon switch is provided, and disables it if -fno-common is provided (and the default setting may vary between compiler versions).

Footnote: I intentionally avoid using the word "defined" in relation to behaviour that is not defined by the C Standard as it seems to me that is one of the cause of confusion for OP.

tl;dr Checkout selectingDate.

Here's what happened.

You're on a case-insenstive filesystem. This is important because Git can store branch names as files; .git/refs/heads/selectingDate contains the commit ID of your selectingDate branch. At some point you did a git checkout SelectingDate which tried to open .git/refs/heads/SelectingDate and opened .git/refs/heads/selectingDate instead.

This sort of works, but there's problems. While SelectingDate will match files named selectingDate, it won't match it in text such as .git/config which might have configuration for [branch "selectingDate"]. Your currently checked out commit is stored in .git/HEAD which now contains ref: refs/heads/SelectingDate.

Then git gc happens and it packs your references. It deletes all the individual files in .git/refs and writes them in one text file .git/packed-refs. Now the branch names are case sensitive! .git/HEAD still says you're on SelectingDate. Git tries to return your checkout to "SelectingDate"'s commits, but it can't find a reference to it in .git/packed-refs and .git/refs/heads/selectingDate is gone. So it thinks it has no commits.

To fix this, checkout selectingDate.

If git branch also shows SelectingDate, delete it.

If you accidentally delete both branches don't panic. Branches are just labels. Restore the branch with git branch selectingDate 910641c4. 910641c4 being the commit ID of your last commit to selectingDate.

See also

• Git Internals - Packfiles
• Git Internals - Git References

I would like to use data initialized in a_test.go inside of b_test.go, is it possible ?

No, this is not possible.

is my assumption [is not possible to share data across different package's tests files] correct ?

Yes.

do you know of any documentation that would enforce the fact ?

Yes. That is how testing works. Running go test will include the _test.go files from the package under test and produce a synthetic main package which can be compiled and linked to an executable which then is executed. No other _test.go files are included ever into that test binary. There is no documentation that explains this "No other!" fact, but this is implicit from the "only the test files from the current".

Provide a "real" package (probably an internal one) providing this test data from non- _test.go files.

One way (I think the only practical way) of solving this problem is to come up with a managed random number generator class that you can pass to your worker function as an argument (the option chosen here) or used to initialize each process in the pool as a global variable. I have modified your code slightly so that instead of printing the random number, function do_thing returns the value and I have also modified the main process to create a pool size of 8 and to invoke do_thing 8 times. Finally, to ensure that all 8 processors each process one submitted task (I have 8 cores) instead of the first process processing all 8 tasks, which is a possibility when the job submitted completes very quickly, I have added a call to sleep to do_thing:

AFAIK there is no cross-DB facade that provides a single interface to talk to multiple Databases at the same time. Be it on-prem/in-cloud or SQL-Server/Synapse/MySQL/...

There are individual ways and means by which you can access a single Database from somewhere/anywhere. E.g. accessing an on-prem DB from code in cloud or access a cloud DB from code running on on-prem "servers". List of interfaces available is specific to each "source" and "target" combination.

One possible way for you to achieve this is to use ipdb and iPython combo.

After a lot of investigation I believe I've found the issue (and it was a lot simpler than I thought).

I noticed that a new session id was being generated on each request (websocket and http). The cause of this issue I believe is because you have secure:true set for your cookies, but I believe you are running this over http not https.

Clear all your cookies, set the secure option to false (You would want it true for a production environment most likely) and run your app again and see if you get the desired results.

You can create and inject it in scene of window group, like