Lesson Code

1617315480

Git and GitHub Crash Course For Beginners

Version control makes managing and rolling back your code look easy. Learn how to differentiate between the files and tools at your disposal to make this happen. Next, learn about Git and how you can leverage that platform to improve your coding abilities. Once you’ve got a grasp on what Git is, you’ll install it and start using it to create and clone code repositories.

 

0:00 Introduction to Version Control
4:06 Keeping Historical Copies
6:20 Diffing Files
10:28 Applying Changes
16:05 Practical Application of diff and patch
21:28 What is Version Control?
25:03 Version Control and Automation
29:47 What is Git?
33:08 Installing Git
36:30 Installing Git on Windows 
43:54 First Steps with Git
48:46 Tracking Files
54:20 The Basic Git Workflow
1:00:56 Anatomy of a Commit Message

This video is part of the Google IT Automation with Python Certificate, providing you with in-demand Python, GIT, and IT automation skills to advance your career in IT. The program, created by Google employees in the field, is designed to provide learners with job-ready skills in about 6 months.

To access the full program content including readings, practice exercises, job search help, and discussion forums please visit ► https://goo.gle/3jB9Re2

Subscribe: https://www.youtube.com/c/GoogleCareerCertificates/featured 

#git #github

What is GEEK

Buddha Community

Git and GitHub Crash Course For Beginners
Sival Alethea

Sival Alethea

1624395600

MongoDB with Python Crash Course - Tutorial for Beginners. DO NOT MISS!!!

Learn the most popular NoSQL / document database: MongoDB. In this quickstart tutorial, you’ll be up and running with MongoDB and Python.
⭐️Course Contents⭐️
⌨️ (0:00:00) Welcome
⌨️ (0:04:33) Intro to MongoDB
⌨️ (0:07:49) How do document DBs work?
⌨️ (0:10:34) Who uses MongoDB
⌨️ (0:13:02) Data modeling
⌨️ (0:16:30) Modeling guidelines
⌨️ (0:22:11) Integration database
⌨️ (0:24:23) Getting demo code
⌨️ (0:30:07) How ODMs work?
⌨️ (0:32:55) Introduction to mongoengine
⌨️ (0:34:01) Demo: Registering connections with MongoEngine
⌨️ (0:37:20) Concept: Registering connections
⌨️ (0:39:14) Demo: Defining mongoengine entities (classes)
⌨️ (0:45:22) Concept: mongoengine entities
⌨️ (0:49:03) Demo: Create a new account
⌨️ (0:56:55) Demo: Robo 3T for viewing and managing data
⌨️ (0:58:18) Demo: Login
⌨️ (1:00:07) Demo: Register a cage
⌨️ (1:10:28) Demo: Add a bookable time as a host
⌨️ (1:16:13) Demo: Managing your snakes as a guest
⌨️ (1:19:18) Demo: Book a cage as a guest
⌨️ (1:33:41) Demo: View your bookings as guest
⌨️ (1:41:29) Demo: View bookings as host
⌨️ (1:46:18) Concept: Inserting documents
⌨️ (1:47:28) Concept: Queries
⌨️ (1:48:09) Concept: Querying subdocuments with mongoengine
⌨️ (1:49:37) Concept: Query using operators
⌨️ (1:50:24) Concept: Updating via whole documents
⌨️ (1:51:46) Concept: Updating via in-place operators
⌨️ (1:54:01) Conclusion

📺 The video in this post was made by freeCodeCamp.org
The origin of the article: https://www.youtube.com/watch?v=E-1xI85Zog8&list=PLWKjhJtqVAbnqBxcdjVGgT3uVR10bzTEB&index=10
🔥 If you’re a beginner. I believe the article below will be useful to you ☞ What You Should Know Before Investing in Cryptocurrency - For Beginner
⭐ ⭐ ⭐The project is of interest to the community. Join to Get free ‘GEEK coin’ (GEEKCASH coin)!
☞ **-----CLICK HERE-----**⭐ ⭐ ⭐
Thanks for visiting and watching! Please don’t forget to leave a like, comment and share!

#mongodb #python #python crash course #mongodb with python crash course - tutorial for beginners #beginners #mongodb with python crash course

Lenora  Hauck

Lenora Hauck

1591848541

Git and GitHub Crash Course

Git and GitHub are used frequently by developers everywhere. These tools are used at most software companies and so they are important to understand if you want a job in the software industry.

We’ve released a crash course video from Gwen Faraday that will teach you the basics of Git and GitHub.

Git is a piece of software that makes it simpler to manage different versions of your own software in a software repository. GitHub is a place to share software repositories and collaborate with other developers. These tools make it easier for multiple people to work on the same software project.

#git #github crash course

7 Best Practices in GIT for Your Code Quality

There is no doubt that Git plays a significant role in software development. It allows developers to work on the same code base at the same time. Still, developers struggle for code quality. Why? They fail to follow git best practices. In this post, I will explain seven core best practices of Git and a Bonus Section.

1. Atomic Commit

Committing something to Git means that you have changed your code and want to save these changes as a new trusted version.

Version control systems will not limit you in how you commit your code.

  • You can commit 1000 changes in one single commit.
  • Commit all the dll and other dependencies
  • Or you can check in broken code to your repository.

But is it good? Not quite.

Because you are compromising code quality, and it will take more time to review codeSo overall, team productivity will be reduced. The best practice is to make an atomic commit.

When you do an atomic commit, you’re committing only one change. It might be across multiple files, but it’s one single change.

2. Clarity About What You Can (& Can’t) Commit

Many developers make some changes, then commit, then push. And I have seen many repositories with unwanted files like dll, pdf, etc.

You can ask two questions to yourself, before check-in your code into the repository

  1. Are you suppose to check-in all these files?
  2. Are they part of your source code?

You can simply use the .gitignore file to avoid unwanted files in the repository. If you are working on more then one repo, it’s easy to use a global .gitignore file (without adding or pushing). And .gitignore file adds clarity and helps you to keep your code clean. What you can commit, and it will automatically ignore the unwanted files like autogenerated files like .dll and .class, etc.

#git basics #git command #git ignore #git best practices #git tutorial for beginners #git tutorials

Monty  Boehm

Monty Boehm

1620027000

Git vs Github: Difference Between Git and Github

IT is in no way different from any other sector when it comes to naming. You would see some systems being named based on their origin while others are named keeping in mind their features or functionality. Then there are some whose names have nothing in common with their origin, features, or anything else related to them.

It is these inconsistencies in naming conventions that make people confused about what a system is all about, what it does, and what benefits it offers. For instance, there are a lot of people out there who still get puzzled when asked about Git and GitHub and whether or not there is a difference between the two.

The similarity in their names has nothing to do with what they really are. They are two altogether different things. But at the same time, you can say that they still have a thing or two in common. Before we talk about Git and GitHub, let us first shed some light on  version control systems (VCSs) and why are they so important.

What is version control?

In simple terms, version control is nothing but a system that keeps track of the changes made to source code or files. With a version control system, you can look back at the changes made to a particular file, either by you or another person, by accessing the version control database. This system gives you the ability to compare different versions of a file, thus allowing you to stay informed about the changes that have happened over a period of time.

The version control system can be referred to as a database that stores snapshots of different files in a project. These snapshots are taken every time a file is modified. It maintains all the records of the different versions of a file. In addition to comparing different versions of a file, VCSs also allows you to switch between them. VCSs can either be distributed or centralized. Let us see how these two types differ.

Centralized version control systems use a single, centralized server to store all the different versions of a file. Users can access these files by gaining access to this centralized server. Now, there is a disadvantage associated with this type of VCS. If the central server fails to function due to any reason, the entire history stored on its will be gone and no one will be able to recover any version/versions of the lost files.

Distributed version control systems have an edge over their centralized counterparts. These VCSs store file versions in two locations – the centralized server and your local machine. So, the disadvantage that we discussed centralized systems doesn’t exist in distributed systems.

Even if the server undergoes failure, you can retrieve all the different versions of your files from your local machine. Suppose you have a file, which is called VersionControl1. Now you made several changes to this file and saved the changes on each occasion. All the changes that you made to this file will be stored in the VCS, which will have all those versions of this file when you made changes to it.

#full stack development #git vs github #git #github

Jade Bird

Jade Bird

1591239790

Git and GitHub Crash Course || Git Tutorial for Beginners

Git is a free and open source distributed version control system.

Generating a new SSH key and adding it to the ssh-agent using git bash

Step1 :
ssh-keygen -t rsa -b 4096 -C (gmail id)

Then u will press enter and at default location shown there: (/c/Users/XXX/.ssh/id_rsa)

start the ssh-agent in the background
$ eval $(ssh-agent -s)

Now add it to agent

ssh-add ~/.ssh/id_rsa

$ git init
With this command we will initialise local directory as git repository. Till now our code is in working area

$ git add . – with dot

Adds the files in the local repository and stages them for commit. These files are prepared to be commited. So now files are moved from working area to staging area

$ git status
to see ur files. In staged, unstaged or untracked status. After commiting u will not see the file here.

$ git commit -m “First commit”

Commits your tracked changes on your local repository and prepares them to be pushed to a remote repository. So now files moves from stage to local repo.

git remote add origin git@github.com:Code-decode-learning/git-demo.git
add url for remote repository in which your local repo will be pushed .

git remote -v
Verify new remote url.

$ git push –u origin master
Pushes the changes in your local repository up to the remote repository you specified as the origin

for forked repos :

Go to your .config file in .git and check upstream and origin.

Upstream should be from where u can take pull. Means your main repo of organisation.

Origin must be your forked where you will push your code and raise a pull request so that on approval those changes can be merged to upstream branch or organisation.

git remote add upstream (url).

git remote add origin(url).

We have already seen:
Git init [repo name] : This command is used to start a new repository.
Git clone : used to obtain a repository from an existing URL into local repository.
Now:

Git add [file] - This command adds a file to the staging area.
Git add .(dot) - This command adds one or more to the staging area.

git diff: Show unstaged changes between your index and working directory.

git commit -m “[ Type in the commit message]”
Usage : git commit –am “my message”

git status : List which files are staged, unstaged, and untracked.

Git log : Display the entire commit history using the default format. For customization see additional options.

git push origin $branchname:$remote_branchname

Git pull -) this command will pull changes from default remote repository which is origin n not upstream, if wanna pull from upstream then use command git pull upstream master.

git fetch: fetches the changes from remote repository but will not affect your local so will not give u any merge confict,
The interesting thing about the fetch command is that it doesn’t actually affect anything in your local repo. No working changes will be lost, and you’ll see no direct affect on your local branches. This is because Git keeps fetched content separate from your own repo’s content until it is merged in.

git fetch (remote-repo)
$ git merge FETCH_HEAD

So obviously the big difference between fetch and pull is that pull actually performs a fetch in addition to a merge.

#git #github #developer