![](https://pawb.social/pictrs/image/531f76a4-b4f3-4eaf-b944-f4228781e2fd.png)
![](https://lemmy.world/pictrs/image/0943eca5-c4c2-4d65-acc2-7e220598f99e.png)
To be honest, you can say the same about any large cloud provider. What happens if AWS, or Azure, or Google Cloud go down, or become terrible?
I’m a Christian and software engineer; I create random graphics projects and websites. Feel free to ask me for help with programming, or about my faith!
To be honest, you can say the same about any large cloud provider. What happens if AWS, or Azure, or Google Cloud go down, or become terrible?
This is probably not the solution you are looking for, given your opinion of the company, but I wonder if using their 1.1.1.1 app (which acts as a mini VPN to a Cloudflare endpoint and changes your public IP) would fix that for you. The upside is it’s free, the downside is that it is a Cloudflare-run VPN.
Check out Ollama and its extensions for VSCode; might save you some money paying for other services if your computer can run models locally.
Just installed, and now I’m wondering why I’ve never found this before. Its great - open source, well-designed, and pretty full-featured
As far as I have heard, if someone is making social posts about a fursuit, it is almost certainly just a normal costume.
To be fair, I have seen many people confused by git (in fact, there is a relevant xkcd). So for you and anyone else that could use some help:
Git is just a version tracker. It is basically like naming a files “project_1”, “project_2”, “project_final”, etc. It just does the hard work of remembering history for you, and only shows you the current version.
The commands are somewhat oddly named, but are fairly intuitive:
git add
- adds some of the current changes to the tracker (“stages” them).
git commit
- commits (i.e. saves) the currently staged changes to a new point in your history (a ‘commit’)
git checkout
- check out, as in take a look at, another branch
And you shouldn’t think about pushing and pulling as a tree; think about it as an action you take. You either pull changes in from the server or you push them up to the server.
For more complex situations, you will need to use more complex functionality. Git is built to help manage changes when working on a team, so it has the concept of creating new branches of history - like an alternate timeline - so that each individual can work on their code as if they were working alone. When they are ready to send their changes to the main (or master) version, they can merge the changes in. In the event that you want to change history, there is git amend and git rebase.
The normal work flow goes like this:
git checkout -b new-feature
: check out a new brach, based on the one you are on nowgit add file.txt (or -A for all)
: add your changes to trackinggit commit
: save the changes to a new commit (a new point in history). This will try to open an editor so you can write a short message explaining the changes; you can use -m "message"
to specify a message from the command line if you prefer.git push
: send your changes to the remote server (add --set-upstream origin new-feature
if this is the first time for this branch)If your changes fall behind the main branch, you will need to update your branch before merging it in. First, checkout the main branch and pull the new changes. Then, checkout your branch and add the changes from main. There are two ways of doing this:
git merge main
- merge the changes you are missing from main, creating a new point in history for the combined changes
git rebase main
- change history so that it is as if your changes started from where main is now - change the base of your branch to be the current state of main.
If there are conflicts, stay calm and take a look at your files. You should see something like this (from here:
here is some content not affected by the conflict
<<<<<<< main
this is conflicted text from main
=======
this is conflicted text from feature branch
>>>>>>> feature branch
You need to edit the file to decide which of main’s code and which of your branch’s code to use. Once you are done, run:
git commit
: if you are doing the merge method
git rebase --continue
: if you are rebasing. A rebase resolves conflicts one commit at a time, so you might be editing code from previous commits, and you might need to repeat this process for the rest of your commits until you get back up to now.
Another tip: if git complains about uncommited changes, or if you just want to save all of your changes somewhere and go back to a clean slate, you can use git stash
. This will create a local stash of your current changes, and allow you to get them back later with git stash apply
or git stash pop
.
And you aren’t expected to remember it all. That’s what man git
, Google, and websites like git.wtf are for. Or, you can call that one friend who understands it, and ask them for help ;)
For anyone who is confused: This is exploiting an old soundness bug in the Rust compiler that is still present. The GitHub issue page has this comment from maintainers: