This document summarizes a lecture on Git introduction and code versioning. It discusses setting up Git locally and globally, basic Git commands like add, commit, branch, merge, and push/pull. It also covers resolving conflicts, rebasing, cherry-picking, and working with remote repositories on GitHub including cloning, forking, pulling requests, and common workflows. Hands-on examples are provided to demonstrate key Git concepts and commands.
Two days git training with labs
First day covers git basis and essential commands
Second day covers git additional command with a big lab using a git workflow
Git is a version control system created by Linus Torvalds in 2005 to manage the Linux kernel source code. It is a distributed system where each user has their own local repository that can be synced with remote repositories. The basic Git workflow involves modifying files locally, staging them, and committing snapshots of the staged files to the local repository. Git tracks changes at a file level and uses SHA-1 hashes to identify commits rather than sequential version numbers.
Git is a distributed version control system that allows developers to work together and track changes to code over time. It keeps track of changes by taking snapshots of the project that create unique IDs for each change. Developers can have their own copy of a repository and commit changes locally before pushing them to a remote server for others to access. This allows for non-linear development with features like branching and merging. GitHub is a popular site for hosting Git repositories online, but Git can also be used locally or with self-hosted servers.
Git is a version control system created by Linus Torvalds in 2005 for tracking changes in source code over time. It allows for non-linear development through features like branching and distributed collaboration. The document provides an overview of common Git concepts and commands including initializing and cloning repositories, tracking file changes, committing snapshots of changes to the local repository, and interacting with remote repositories by pushing and pulling changes. Best practices for Git include not pushing directly to master, defining code owners, avoiding secrets and dependencies in commits, and maintaining a meaningful .gitignore file.
Git is a version control system that tracks changes to files. It has three main states that files can be in: modified, staged, and committed. The document provides an overview of Git and GitHub, including how to initialize a local Git repository, add and commit files, push changes to GitHub, fork and clone remote repositories, and make pull requests to contribute code back to the original project. Key Git commands are demonstrated through an example workflow of editing, adding, committing, and pushing files.
The document discusses advantages of using Git over centralized version control systems like SVN. It notes that Git is distributed, meaning the full history is stored locally on each user's machine with no single point of failure. It also summarizes that Git is extremely fast for local operations since there is no network latency. Additionally, Git repositories and working directories take up much less disk space than SVN. The document provides examples of Git commands for basic workflows like committing, branching, merging, and pushing/pulling changes. It also discusses strategies for code reviews and rebasing vs merging branches in Git.
- Git is a distributed version control system designed by Linus Torvalds for Linux kernel development
- It is better than Subversion because it is distributed, allows lightweight branching and merging, requires less disk space, and has no single point of failure
- Common Git commands include git init to initialize a repository, git add to stage files for committing, git commit to commit staged changes, and git push/pull to transfer commits between local and remote repositories
Two days git training with labs
First day covers git basis and essential commands
Second day covers git additional command with a big lab using a git workflow
Git is a version control system created by Linus Torvalds in 2005 to manage the Linux kernel source code. It is a distributed system where each user has their own local repository that can be synced with remote repositories. The basic Git workflow involves modifying files locally, staging them, and committing snapshots of the staged files to the local repository. Git tracks changes at a file level and uses SHA-1 hashes to identify commits rather than sequential version numbers.
Git is a distributed version control system that allows developers to work together and track changes to code over time. It keeps track of changes by taking snapshots of the project that create unique IDs for each change. Developers can have their own copy of a repository and commit changes locally before pushing them to a remote server for others to access. This allows for non-linear development with features like branching and merging. GitHub is a popular site for hosting Git repositories online, but Git can also be used locally or with self-hosted servers.
Git is a version control system created by Linus Torvalds in 2005 for tracking changes in source code over time. It allows for non-linear development through features like branching and distributed collaboration. The document provides an overview of common Git concepts and commands including initializing and cloning repositories, tracking file changes, committing snapshots of changes to the local repository, and interacting with remote repositories by pushing and pulling changes. Best practices for Git include not pushing directly to master, defining code owners, avoiding secrets and dependencies in commits, and maintaining a meaningful .gitignore file.
Git is a version control system that tracks changes to files. It has three main states that files can be in: modified, staged, and committed. The document provides an overview of Git and GitHub, including how to initialize a local Git repository, add and commit files, push changes to GitHub, fork and clone remote repositories, and make pull requests to contribute code back to the original project. Key Git commands are demonstrated through an example workflow of editing, adding, committing, and pushing files.
The document discusses advantages of using Git over centralized version control systems like SVN. It notes that Git is distributed, meaning the full history is stored locally on each user's machine with no single point of failure. It also summarizes that Git is extremely fast for local operations since there is no network latency. Additionally, Git repositories and working directories take up much less disk space than SVN. The document provides examples of Git commands for basic workflows like committing, branching, merging, and pushing/pulling changes. It also discusses strategies for code reviews and rebasing vs merging branches in Git.
- Git is a distributed version control system designed by Linus Torvalds for Linux kernel development
- It is better than Subversion because it is distributed, allows lightweight branching and merging, requires less disk space, and has no single point of failure
- Common Git commands include git init to initialize a repository, git add to stage files for committing, git commit to commit staged changes, and git push/pull to transfer commits between local and remote repositories
This document provides an overview of version control with Git. It explains what version control and Git are, how to install and configure Git, how to perform basic tasks like initializing a repository and making commits, and how to collaborate using features like branching and pushing/pulling from remote repositories. Key points covered include allowing the tracking of changes, maintaining file history, and enabling multiple people to work on the same project simultaneously without conflicts.
Git is version control software that allows tracking changes to code over time. It allows easy collaboration and offline work. Git works with entire code repositories rather than individual files, offering better performance than other version control systems. The basic Git workflow involves adding files, committing changes to a local repository, and pushing commits to a remote server repository. Branches allow isolated development and merging of features.
Git is a distributed version control system that allows developers to work on projects locally before pushing changes to remote repositories. It uses snapshots of file changes and checksums rather than file version numbers to track file history. The basic Git workflow involves modifying files locally, staging changes, and committing snapshots of the staged changes to the local repository. Changes can then be pulled from and pushed to remote repositories like GitHub.
Git is a distributed version control system, created by Linus Torvalds, and used worldwide by many software developers for a large number of well known software projects.
In this presentation, I explain the fundamentals of the Git software and some of its internal workings and related terminology. The target audience is individuals who have used Git before in a limited capacity and want expand their knowledge of the software to improve their daily use of it. The presentation could also be useful for those with knowledge of Git and a desire to improve their understanding of some of the more technically elements.
Git is a version control system that records changes to files over time, allowing users to recall specific versions. It is a distributed system where each local repository has a full copy of the project files and history, allowing offline work. Users can clone repositories locally or remotely. Files are added and committed with messages to save snapshots, and commits can be visualized. Changes are pushed to remote repositories to share work, and branches allow independent lines of development that can be merged together. Tags mark important commits, and errors can be fixed by resetting files or the repository state.
Git is a version control system that records changes to files over time, allowing users to recall specific versions. It is a distributed system where each local repository has a full copy of the project files and history, allowing offline work. Users can clone repositories locally or remotely. Files are added and committed with messages to save snapshots, and commits can be visualized. Changes are pushed to remote repositories to share work, and branches allow independent lines of development that can be merged together. Tags mark important commits, and errors can be fixed by resetting files or the repository state.
This document provides an introduction to version control with Git. It discusses the basic Git model and workflow, including cloning repositories, making local changes, staging files, and committing changes. It compares Git to centralized version control systems like Subversion and highlights Git's distributed and non-linear development advantages. Basic Git commands are explained like add, commit, status, diff, log, pull and push. Branching and merging with Git are also introduced.
Git 101 - Crash Course in Version Control using GitGeoff Hoffman
Find out why more and more developers are switching to Git - distributed version control. This intro to Git covers the basics, from cloning to pushing for beginners.
This document introduces the version control system Git. It discusses:
- The creator of Git, Linus Torvalds, who developed it to enable collaboration on open source projects.
- What Git is used for, including managing code versions, group collaboration, and reverting to old versions.
- How to download and set up Git on different operating systems.
- Important Git commands for adding, committing, pushing, pulling changes and resolving conflicts when merging branches.
- Alternatives to the command line interface for Git including graphical user interfaces and GitHub.
The document provides an overview of version control systems and introduces Git and GitHub. It discusses the differences between centralized and distributed version control. It then covers the basics of using Git locally including initialization, staging files, committing changes, branching and merging. Finally, it demonstrates some common remote operations with GitHub such as pushing, pulling and tagging releases.
Git is a version control system that allows developers to track changes to files over time. It is distributed, meaning developers have their own local copy of the code repository. This allows working offline and merging changes. Common Git commands include git add to stage changes, git commit to save changes locally, and git push to upload changes to the remote repository. Tagging specific versions with git tag allows easy deployment of code.
Git workshop - University of Moratuwa, Department of Computer Science and Eng...WSO2
This document provides an overview of Git and how to use it for version control. It discusses why version control is useful, how to install and configure Git, how to create and clone repositories on GitHub, and the basic Git commands for committing changes, checking differences, pulling and pushing to repositories, ignoring files, stashing changes, working with branches, resolving conflicts, tagging releases, and using GUI tools.
Git allows for managing changes to documents and code. It provides resilience, collaboration, efficiency and accountability through features like branching and merging. Users can create local repositories, push changes to remote repositories hosted on services like GitHub, and pull updates from remote repositories. Managing changes involves commands like add, commit, push, pull and resolving any conflicts that arise from concurrent changes.
This document provides an overview of Git, including:
1. Git is an open source distributed version control system that allows for distributed workflows where each clone is a full backup.
2. Basic Git commands include configuring user information, cloning repositories, ignoring files, adding and committing changes, branching, tagging, and undoing actions.
3. A typical Git workflow involves writing code, staging changes, reviewing changes, committing changes locally, and pushing changes to a remote repository. It also covers merging, resolving conflicts, and rolling back if needed.
This document provides an overview of version control with Git. It explains what version control and Git are, how to install and configure Git, how to perform basic tasks like initializing a repository and making commits, and how to collaborate using features like branching and pushing/pulling from remote repositories. Key points covered include allowing the tracking of changes, maintaining file history, and enabling multiple people to work on the same project simultaneously without conflicts.
Git is version control software that allows tracking changes to code over time. It allows easy collaboration and offline work. Git works with entire code repositories rather than individual files, offering better performance than other version control systems. The basic Git workflow involves adding files, committing changes to a local repository, and pushing commits to a remote server repository. Branches allow isolated development and merging of features.
Git is a distributed version control system that allows developers to work on projects locally before pushing changes to remote repositories. It uses snapshots of file changes and checksums rather than file version numbers to track file history. The basic Git workflow involves modifying files locally, staging changes, and committing snapshots of the staged changes to the local repository. Changes can then be pulled from and pushed to remote repositories like GitHub.
Git is a distributed version control system, created by Linus Torvalds, and used worldwide by many software developers for a large number of well known software projects.
In this presentation, I explain the fundamentals of the Git software and some of its internal workings and related terminology. The target audience is individuals who have used Git before in a limited capacity and want expand their knowledge of the software to improve their daily use of it. The presentation could also be useful for those with knowledge of Git and a desire to improve their understanding of some of the more technically elements.
Git is a version control system that records changes to files over time, allowing users to recall specific versions. It is a distributed system where each local repository has a full copy of the project files and history, allowing offline work. Users can clone repositories locally or remotely. Files are added and committed with messages to save snapshots, and commits can be visualized. Changes are pushed to remote repositories to share work, and branches allow independent lines of development that can be merged together. Tags mark important commits, and errors can be fixed by resetting files or the repository state.
Git is a version control system that records changes to files over time, allowing users to recall specific versions. It is a distributed system where each local repository has a full copy of the project files and history, allowing offline work. Users can clone repositories locally or remotely. Files are added and committed with messages to save snapshots, and commits can be visualized. Changes are pushed to remote repositories to share work, and branches allow independent lines of development that can be merged together. Tags mark important commits, and errors can be fixed by resetting files or the repository state.
This document provides an introduction to version control with Git. It discusses the basic Git model and workflow, including cloning repositories, making local changes, staging files, and committing changes. It compares Git to centralized version control systems like Subversion and highlights Git's distributed and non-linear development advantages. Basic Git commands are explained like add, commit, status, diff, log, pull and push. Branching and merging with Git are also introduced.
Git 101 - Crash Course in Version Control using GitGeoff Hoffman
Find out why more and more developers are switching to Git - distributed version control. This intro to Git covers the basics, from cloning to pushing for beginners.
This document introduces the version control system Git. It discusses:
- The creator of Git, Linus Torvalds, who developed it to enable collaboration on open source projects.
- What Git is used for, including managing code versions, group collaboration, and reverting to old versions.
- How to download and set up Git on different operating systems.
- Important Git commands for adding, committing, pushing, pulling changes and resolving conflicts when merging branches.
- Alternatives to the command line interface for Git including graphical user interfaces and GitHub.
The document provides an overview of version control systems and introduces Git and GitHub. It discusses the differences between centralized and distributed version control. It then covers the basics of using Git locally including initialization, staging files, committing changes, branching and merging. Finally, it demonstrates some common remote operations with GitHub such as pushing, pulling and tagging releases.
Git is a version control system that allows developers to track changes to files over time. It is distributed, meaning developers have their own local copy of the code repository. This allows working offline and merging changes. Common Git commands include git add to stage changes, git commit to save changes locally, and git push to upload changes to the remote repository. Tagging specific versions with git tag allows easy deployment of code.
Git workshop - University of Moratuwa, Department of Computer Science and Eng...WSO2
This document provides an overview of Git and how to use it for version control. It discusses why version control is useful, how to install and configure Git, how to create and clone repositories on GitHub, and the basic Git commands for committing changes, checking differences, pulling and pushing to repositories, ignoring files, stashing changes, working with branches, resolving conflicts, tagging releases, and using GUI tools.
Git allows for managing changes to documents and code. It provides resilience, collaboration, efficiency and accountability through features like branching and merging. Users can create local repositories, push changes to remote repositories hosted on services like GitHub, and pull updates from remote repositories. Managing changes involves commands like add, commit, push, pull and resolving any conflicts that arise from concurrent changes.
This document provides an overview of Git, including:
1. Git is an open source distributed version control system that allows for distributed workflows where each clone is a full backup.
2. Basic Git commands include configuring user information, cloning repositories, ignoring files, adding and committing changes, branching, tagging, and undoing actions.
3. A typical Git workflow involves writing code, staging changes, reviewing changes, committing changes locally, and pushing changes to a remote repository. It also covers merging, resolving conflicts, and rolling back if needed.
This presentation was provided by Racquel Jemison, Ph.D., Christina MacLaughlin, Ph.D., and Paulomi Majumder. Ph.D., all of the American Chemical Society, for the second session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session Two: 'Expanding Pathways to Publishing Careers,' was held June 13, 2024.
Walmart Business+ and Spark Good for Nonprofits.pdfTechSoup
"Learn about all the ways Walmart supports nonprofit organizations.
You will hear from Liz Willett, the Head of Nonprofits, and hear about what Walmart is doing to help nonprofits, including Walmart Business and Spark Good. Walmart Business+ is a new offer for nonprofits that offers discounts and also streamlines nonprofits order and expense tracking, saving time and money.
The webinar may also give some examples on how nonprofits can best leverage Walmart Business+.
The event will cover the following::
Walmart Business + (https://business.walmart.com/plus) is a new shopping experience for nonprofits, schools, and local business customers that connects an exclusive online shopping experience to stores. Benefits include free delivery and shipping, a 'Spend Analytics” feature, special discounts, deals and tax-exempt shopping.
Special TechSoup offer for a free 180 days membership, and up to $150 in discounts on eligible orders.
Spark Good (walmart.com/sparkgood) is a charitable platform that enables nonprofits to receive donations directly from customers and associates.
Answers about how you can do more with Walmart!"
How to Setup Warehouse & Location in Odoo 17 InventoryCeline George
In this slide, we'll explore how to set up warehouses and locations in Odoo 17 Inventory. This will help us manage our stock effectively, track inventory levels, and streamline warehouse operations.
Beyond Degrees - Empowering the Workforce in the Context of Skills-First.pptxEduSkills OECD
Iván Bornacelly, Policy Analyst at the OECD Centre for Skills, OECD, presents at the webinar 'Tackling job market gaps with a skills-first approach' on 12 June 2024
Chapter wise All Notes of First year Basic Civil Engineering.pptxDenish Jangid
Chapter wise All Notes of First year Basic Civil Engineering
Syllabus
Chapter-1
Introduction to objective, scope and outcome the subject
Chapter 2
Introduction: Scope and Specialization of Civil Engineering, Role of civil Engineer in Society, Impact of infrastructural development on economy of country.
Chapter 3
Surveying: Object Principles & Types of Surveying; Site Plans, Plans & Maps; Scales & Unit of different Measurements.
Linear Measurements: Instruments used. Linear Measurement by Tape, Ranging out Survey Lines and overcoming Obstructions; Measurements on sloping ground; Tape corrections, conventional symbols. Angular Measurements: Instruments used; Introduction to Compass Surveying, Bearings and Longitude & Latitude of a Line, Introduction to total station.
Levelling: Instrument used Object of levelling, Methods of levelling in brief, and Contour maps.
Chapter 4
Buildings: Selection of site for Buildings, Layout of Building Plan, Types of buildings, Plinth area, carpet area, floor space index, Introduction to building byelaws, concept of sun light & ventilation. Components of Buildings & their functions, Basic concept of R.C.C., Introduction to types of foundation
Chapter 5
Transportation: Introduction to Transportation Engineering; Traffic and Road Safety: Types and Characteristics of Various Modes of Transportation; Various Road Traffic Signs, Causes of Accidents and Road Safety Measures.
Chapter 6
Environmental Engineering: Environmental Pollution, Environmental Acts and Regulations, Functional Concepts of Ecology, Basics of Species, Biodiversity, Ecosystem, Hydrological Cycle; Chemical Cycles: Carbon, Nitrogen & Phosphorus; Energy Flow in Ecosystems.
Water Pollution: Water Quality standards, Introduction to Treatment & Disposal of Waste Water. Reuse and Saving of Water, Rain Water Harvesting. Solid Waste Management: Classification of Solid Waste, Collection, Transportation and Disposal of Solid. Recycling of Solid Waste: Energy Recovery, Sanitary Landfill, On-Site Sanitation. Air & Noise Pollution: Primary and Secondary air pollutants, Harmful effects of Air Pollution, Control of Air Pollution. . Noise Pollution Harmful Effects of noise pollution, control of noise pollution, Global warming & Climate Change, Ozone depletion, Greenhouse effect
Text Books:
1. Palancharmy, Basic Civil Engineering, McGraw Hill publishers.
2. Satheesh Gopi, Basic Civil Engineering, Pearson Publishers.
3. Ketki Rangwala Dalal, Essentials of Civil Engineering, Charotar Publishing House.
4. BCP, Surveying volume 1
Leveraging Generative AI to Drive Nonprofit InnovationTechSoup
In this webinar, participants learned how to utilize Generative AI to streamline operations and elevate member engagement. Amazon Web Service experts provided a customer specific use cases and dived into low/no-code tools that are quick and easy to deploy through Amazon Web Service (AWS.)
8. GIT LOCAL FLOW - EXAMPLE
8
Commit Branch Merge
F1 F2 F4 F4+
F3 F4*
9. GIT LOCAL FLOW - EXAMPLE
9
F1 F2 F4
Server
PC
Init
F1 F2 F4
Init
Clone
Push
Class 2
Class 2
Pull
10. IT’S HANDS ON TIME
• 2 Moments
• Moment 1:
– Local commands: add, commit, branch, merge, conflicts..
• Moment 2
– Interaction with the remote repo: Push, pull
10
11. KICKING OFF
• git config --global user.name “Igor Steinmacher”
• git config --global user.email “igor.Steinmacher@nau.edu”
• Create a folder / access this folder
• git init
– This folder is a repo
11
For all repos
12. HANDS ON
• Create a file
• Check the status of the repo
– git status
• Add the file to the index
– git add <filename>
• Check the status
12
13. HANDS ON
• Our first commit
– git -a -m “Our first commit!!!”
• -a all files
• -m will include a commit message
• Check the last commits
– git log
• Check what has been done in the last commit
– git show
13
14. HANDS ON
• Let’s!
– Change the file
– git status
– git commit …
– git status
– git log
• And this is the basic flow to put your contributions back to the
repo
– add
– commit
– status
– log
– show
14
15. LET’S BRANCH IT OUT!
• Listing your branches
– git branch
• Create a branch
– git branch <NEW_BRANCH>
• Use another branch
– git checkout <BRANCH_NAME>
• Latest two in one command
– git checkout –b <NEW_BRANCH>
15
16. WORKING IN A NEW BRANCH
• git checkout -b branchNew
• <Change one existing file here>
– “Hi, my name is Hugh.”
• git commit -a -m “Introducing myself”
• <Check the content of the file>
• git checkout master
• <Check the content of the file>
– What?!?!
16
17. UPDATING THE MASTER BRANCH
• Usually we branch out for versions, features, bug fixes…
– Later on merging back to master
• How to merge our recently changed file, then?
– In the master branch:
– git merge <other_branch>
• If everything goes smooth… sweet
17
18. DEALING WITH SMALL CONFLICTS
• Imagine if you change a file in your branch, and someone else
changed the same file
– CONFLICT!!!!
• Can we still merge it?!?!?
– Let’s see:
• Change branch
• Change file
• Commit
• Back to master
• Change the same file
• Commit
• MERGE!
18
19. USUALLY… FOR THE EASY ONES
Here comes common text before
the area where the conflict happens
and bla bla bla
<<<<<<< HEAD
This is what was in the
master branch
=======
And this…
was in the other branch
>>>>>>> other branch
More text that was common,
and no conflict happened here
19
20. EXERCISING IT OUT
• Make a new branch called bugfix
• Checkout the bugfix branch with git checkout bugfix
• Create/change a file and commit
• Go back to master with git checkout
• Change/create a file (different from the previous one) and commit
again
• Merge the branch bugfix into master with git merge
20
21. REBASING IT ALL!!!
• Another way of combining branches
• We can take a set of commits, and copy them in another branch
• Master and our branch are not sync’ed
– Commit made in master
– Commit made in the branch
• From the branch, we can
– git rebase master
– Now the index of the master is “outdated” HEAD is pointing to
bugfix last commit
• git log --graph --all
21
22. MOVING FROM HERE TO THERE
• HEAD is the pointer name for the last checked out commit
• We can “detach” the head by “checking out” a specific commit
– git checkout <commit SHA>
• This is not “safe”
– git checkout <branch>
• To get back
• Moving in the commit tree
– Moving one commit at a time with ^
• git checkout HEAD^
• git checkout master^
– Moving a number of times with ~<num>
• git checkout master~3
22
23. MOVING FROM HERE TO THERE
• We can move a branch!
– git branch -f <BRANCH> HEAD~3
• We can also revert changes
– git reset HEAD~2
• Move the current branch to HEAD - 2 commits position
• Works LOCAL
• git reflog see previous commits
• git reset <SHA> SHA of the commit before the reset for
“unresetting”
– git revert HEAD To reverse changes to send upstream
23
24. CHERRY-PICKING
• Use when you don’t want to copy ALL commits from a branch to
another
– We can cherry pick those that are of interest
• git cherry-pick <SHA1> <SHA2> <SHA3>
24
27. CLONING TO A LOCAL REPO
• That’s simple! Cloning means bringing all the history to a local
repo
– git clone https://github.com/<owner>/<repo>
• Testing it out
– git clone https://github.com/NAU-OSS/githandson.git
Cloning into 'githandson'...
warning: You appear to have cloned an empty repository.
27
28. WORKING IN THIS REPO
• Some different commands to deal with remote repo
– git branch –r
– git pull //pulls everything from the remote repo and updates the local
repo
– git fetch //pulls changes from remote repos, but it doesn't integrate any
of this new data into your working files
– git push
• git push <remoteName> <branchName> //push your local changes
to an online repository (git push origin master)
• git push <remoteName> <localBranchName>:<remoteBranchName>
// This pushes the LOCALBRANCHNAME to your REMOTENAME,
but it is renamed to REMOTEBRANCHNAME.
28
29. USUAL WORKFLOW
• git clone
– branch out to add your changes locally
– your adds/commits
– pull changes to your local repo
– merge your branch back (LOCALLY)
• Resolve any conflict
– push changes back to the remote repo
29
30. GITHUB WORKFLOW
• Fork + pull-request
– You usually creates a fork for your repo
• “A fork is a copy of a repository. Forking a repository allows you to
freely experiment with changes without affecting the original project”
– Creating a fork
– Then, you usually clone your fork… work, and send a pull request
against the main repo
30