coworkers | A RabbitMQ Microservice Framework in Node.js | Pub Sub library

What you are experiencing is called "collapsing margins". Example: If there's an h2 as the first child element inside a div, and the div has no margins, the top margin of the h2 will "go outside the div" at the top - h1, h2 etc. tags have a default margins in practically all browsers (which is a browser setting). To prevent that, you can define all margins for according elements as zero, like I did below with

While you generally do not merge merge to another branch, in this particular scenario, that would be the more practical option (as in "merge master to a branch")

Rebasing a branch used by other branches gets tricky real fast, and the rebase operation is best reserved to branches not used by other branches.

As per my understanding of the question, I came up with this solution. Give it a try.

Not sure what changed, but uninstalling and reinstalling the SQLServer module and then adding import-module sqlserver at the top of the script seems to have fixed it

The reason for the problem with these files is the large offset combined with 32-bit float values. In this case the objects all use the same geographic origin, probably at a lat/long of 0.000N/0.000E

Nearly all 3D graphics programs use 32-bit floating point values to store each points location, and the combination of the offset and the 32-bit value causes some of the precision to be lost. 32-bit floats have about 7 decimal digits of precision, so the offset of 4460688 in the example file completely dominates, and effectively cuts the model from 1mm resolution to 1m resolution data. The reason for the long triangles is that there is more data lost in one direction due to the asymmetry of the offset.

The solution is to apply some offset to bring the objects close to the origin BEFORE importing them with the 3D software. I wrote a quick python script that can help with this: https://gitlab.umich.edu/lsa-ts-rsp/xr-shiftOBJ/-/blob/main/shiftOBJ.py

Unfortunately, there is no trivial way to get what you'd like here. Both this form of git checkout and the newfangled git restore command assume that when you ask Git to overwrite $file in your working tree from the version found in $hash, you really mean it—even if $file already exists in your working tree and differs from the copy in the index and/or in HEAD.

What you can do is write your own Git command. Pick a command name that does not yet exist. (I do not know what to call this command, so I'll pick xyzzy, one of the two magic words from Colossal Cave Adventure.) Create an executable program—in any language you like; I usually use shell scripts here—named git-xyzzy and place it in your $PATH. Then, when you run git xyzzy, Git will run your command.

Your command should:

• take a $hash and some set of $file arguments (you choose how to do this);
• check that the given $file arguments either do not exist in the working tree, or are safely committed; and
• run git restore or git checkout as appropriate.

That's generally a pretty short script, mostly using git rev-parse on hash IDs and git diff or git hash-object to check whether the file is safely committed.

Specifically,

Is it true that when using Git ... we have to ...?

Is this the only way to make it work?

Well, no. There are multiple different ways to do it, even in Git. But both of the ways you specifically asked about, are (IMHO) decent workable solutions, but perhaps could use some minor (conceptual) tweaking.

Side Note: you didn't state it explicitly, but you implied that you intend to serve your app out of a directory inside of the repo. I tend to avoid doing this. Instead, I would have the repo off to the side and use deployment scripts to move the appropriate subset of files to the served location. The benefits of this is you can pick and choose exactly which subset of files are served, and, perhaps more importantly, the served location is more likely to be clean. For example, when a Git repo is in the middle of an operation that has conflicts which require manual intervention, it is oftentimes not in a usable state. That being said, many people serve out of a repo and (AFAIK) it works for them.

As for some ideas:

1. 3 different directories on the server: From a Git point of view, I would actually consider this a subset of Option #2 or #3. I don't think you need 3 separate copies of the repo; just one would suffice. But you could still have the 3 different sets of code deployed into 3 different directories on the server, each one represented by a different commit. If it's easy enough, instead of changing which directory the endpoint uses, you could set up 3 endpoints at the same time so that the audience can see all 3 without any delay (or even try each one themselves at any time).
2. 3 different commits on the same branch: this is actually how many people develop code naturally: Make a new branch to work on. Try something and commit it. Tweak it or completely redo it and make another commit. (Note right here you don't have to comment out the previous try, just replace it completely since it's already saved in the previous commit.) Tweak some more and commit it. If you do this, for your demo purposes, you can either git reset --hard [commit-id] or git checkout [commit-id] to switch between the states of the specific commits you want, and deploy that to the served directory (if you aren't already serving out of the repo).
3. 3 different branches: note that a branch basically just points to a commit ID, so whether the 3 commits are on the same branch or different branches doesn't really matter. The main difference is if you use different branches, you get the benefit of checking out with a nice text name: git checkout cool-feature-test1 or git checkout cool-feature-test2, etc. Note, you could actually do something similar even if the commits are on the same branch, by instead tagging the commit IDs with a nice name, and then just checking out the nicely named tag instead of the commit ID. I might avoid using tags though on stuff that is likely going to be thrown away at some point. If you were about to tag commits on the same branch just for this reason, then I'd instead make new branches from each of those commits, and you end up at #3 anyway.

If it were me, I'd probably combine #3 (separate branches) and #1 (multiple endpoints). I prefer #3 so I don't have to remember exactly which commit IDs to switch back to, and #1 so I could just give the testers the URLs and ask them for feedback on their own time. (#1 is also nice if deployment takes a while in a live demo, particularly if any code requires compilation.) With #3 you also get an added benefit of being able to tweak each try separately if you intend to make additional edits to more than one attempt after the demo.

Again, any of these should work just fine. I wouldn't stress out too much about which way to go. Pick something and try it, and then adjust if you find the need.

I was able to solve this issue by adding a views.py file in C:\Users\username\AppData\Roaming\Python\Python39\site-packages\django\views. In the file was this code:

Select "Matching Names" option. It will match the names of both tables. Then select the UUID field option as "Match records based on this field". Now the "Matching Names" automatically changed to "Custom Order". It will still remember the field mapping.