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 introduction to Git and GitHub. It begins with an overview of source control and the history of version control systems like SVN and CVS. It then discusses key concepts of Git like its three-tree architecture, branches and merging, and undoing changes. The document concludes with an introduction to GitHub, how to clone and collaborate on repositories, and some tips on reducing merge conflicts.
This document provides an outline for a course on learning Git version control. The course covers getting Git setup, the basic concepts and workflow of Git, branching and merging, resolving conflicts, working with remote repositories, and various Git commands. The document lists several modules that will be covered, including getting started, everyday Git usage, branching, merging and rebasing, additional tools and concepts, and advice on applying the skills learned. The goal is to teach participants how to install and use Git for version control on individual, local, and distributed projects.
This document discusses using Git and GitHub for version control. It covers Git terminology and commands for initializing a Git repository, configuring Git, adding and committing files, branching and merging, and using an code editor with Git. Key points include using 'git init' to create a new local repository, 'git add' to stage files for committing, 'git commit' to save changes to the repository, and 'git branch', 'git checkout' and 'git merge' for managing branches. The document provides guidance on writing good commit messages and installing Git on different operating systems.
One of the biggest advantages of Git is its branching capabilities. Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow popular with many Git users.
The document discusses Git and GitHub. It begins with an overview of distributed version control systems (DVCS) like Git and how they differ from centralized version control systems. It then covers the basics of Git, including installing Git, initializing repositories, tracking changes, branching and merging. Finally, it discusses GitHub and how developers can use features like forking, pull requests and wikis to collaborate on projects hosted there. Common Git workflows like Git flow are also introduced.
This document provides an introduction to using Git and GitHub for version control of documents and collaboration. It explains the basic workflow of creating, editing, and saving files individually. It then introduces Git as a tool to track changes to documents over time, including who made each change and when. The document outlines setting up Git locally and using basic commands like commit, diff, log, branch, merge, and push/pull to the remote GitHub repository. It highlights key GitHub features like the profile page, repository page, pull requests, and hosting websites for free using GitHub Pages.
Github - Git Training Slides: FoundationsLee Hanxue
Slide deck with detailed step breakdown that explains how git works, together with simple examples that you can try out yourself. Slides originated from http://teach.github.com/articles/course-slides/
Author: https://twitter.com/matthewmccull
GitHub is where over 73 million developers shape the future of software, together. Contribute to the open source community, manage your Git repositories
This document provides an introduction to Git and GitHub. It begins with an overview of source control and the history of version control systems like SVN and CVS. It then discusses key concepts of Git like its three-tree architecture, branches and merging, and undoing changes. The document concludes with an introduction to GitHub, how to clone and collaborate on repositories, and some tips on reducing merge conflicts.
This document provides an outline for a course on learning Git version control. The course covers getting Git setup, the basic concepts and workflow of Git, branching and merging, resolving conflicts, working with remote repositories, and various Git commands. The document lists several modules that will be covered, including getting started, everyday Git usage, branching, merging and rebasing, additional tools and concepts, and advice on applying the skills learned. The goal is to teach participants how to install and use Git for version control on individual, local, and distributed projects.
This document discusses using Git and GitHub for version control. It covers Git terminology and commands for initializing a Git repository, configuring Git, adding and committing files, branching and merging, and using an code editor with Git. Key points include using 'git init' to create a new local repository, 'git add' to stage files for committing, 'git commit' to save changes to the repository, and 'git branch', 'git checkout' and 'git merge' for managing branches. The document provides guidance on writing good commit messages and installing Git on different operating systems.
One of the biggest advantages of Git is its branching capabilities. Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow popular with many Git users.
The document discusses Git and GitHub. It begins with an overview of distributed version control systems (DVCS) like Git and how they differ from centralized version control systems. It then covers the basics of Git, including installing Git, initializing repositories, tracking changes, branching and merging. Finally, it discusses GitHub and how developers can use features like forking, pull requests and wikis to collaborate on projects hosted there. Common Git workflows like Git flow are also introduced.
This document provides an introduction to using Git and GitHub for version control of documents and collaboration. It explains the basic workflow of creating, editing, and saving files individually. It then introduces Git as a tool to track changes to documents over time, including who made each change and when. The document outlines setting up Git locally and using basic commands like commit, diff, log, branch, merge, and push/pull to the remote GitHub repository. It highlights key GitHub features like the profile page, repository page, pull requests, and hosting websites for free using GitHub Pages.
Github - Git Training Slides: FoundationsLee Hanxue
Slide deck with detailed step breakdown that explains how git works, together with simple examples that you can try out yourself. Slides originated from http://teach.github.com/articles/course-slides/
Author: https://twitter.com/matthewmccull
GitHub is where over 73 million developers shape the future of software, together. Contribute to the open source community, manage your Git repositories
Introduction To Git For Version Control Architecture And Common Commands Comp...SlideTeam
Introduction To Git For Version Control Architecture And Common Commands Complete Deck is an impact virtual tool. Employ our PowerPoint presentation to acquaint your audience with the version management system. This PPT slideshow is ideal to effectively elucidate GIT version control software through the visual aid of industry-best diagrams. Elaborate on the need for GIT by your organization. Consolidate the advantages of the GIT distributed version control application using our PowerPoint layout. Data visualizations featured in this PPT template deck facilitate a better explanation of the GIT architecture. You can also convey the features of this distributed revision control tool. Compile the common commands used in GIT with appreciable ease. Present vital information about the revision control system such as working with remote repositories by the means of our PowerPoint format. This is a must-have virtual solution, especially for upper and mid-level management. So, hit the download icon now and instantly start building an impressive presentation. https://bit.ly/3nMK6c4
Introduction to Git & GitHub.
Agenda:
- What’s a Version Control System?
- What the heck is Git?
- Some Git commands
- What’s about GitHub?
- Git in Action!
GIT is a free and open source distributed version control system that allows developers to work collaboratively without needing centralized connectivity. It provides powerful branching capabilities that allow creating branches cheaply and merging them easily. Common GIT commands include init, clone, status, add, commit, log, remote, fetch, push, and pull. An example scenario demonstrates how multiple developers can clone a remote repository, make changes on their local repos, fetch and push changes between local and remote repos, and merge branches.
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.
This document provides an introduction to using Git version control. It discusses key Git concepts like distributed version control, objects in Git like blobs and trees, and commands like add, commit, branch, merge, rebase, fetch and push. The introduction includes an agenda, sources for further information, and demos several Git workflows and commands.
Git 101 Presentation
The presentation introduces Git version control system including:
[1] An overview of version control systems and the basics of Git such as snapshots, local operations, and three main states of files.
[2] A comparison of features between Git and SVN such as distributed development and branching workflows.
[3] Instructions on setting up Git locally and with GitHub, and basic commands for creating and managing repositories, branches, commits, and merges.
This document provides an overview of GitHub and its technical architecture presented by Chris Wanstrath. Some key points:
- GitHub started as a git hosting site but became a social coding platform where users can see friends' activity and leave comments.
- It uses Ruby on Rails for the main codebase, Resque for background jobs, MySQL for the database, and nginx, unicorn, and memcached.
- Git operations are handled by Grit and communicated to file servers via the BERT-RPC based Smoke protocol.
- Caching, asset optimization, and AJAX loading are used extensively to improve performance. Monitoring tools include Nagios, Resque Web, Haystack, and CollectD.
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.
This document provides a summary of a mini Git tutorial. It begins with an introduction to version control systems and how they allow users to track changes, revert files, and recover from errors. It then explains the basics of Git, including its three main states (committed, modified, staged), how it stores content addressed by SHA-1 hashes, and the local workflow of modifying, staging, and committing files. The document proceeds to cover installing Git, basic configuration, cloning repositories, recording changes, undoing actions, and working with remote repositories hosted online. It concludes by mentioning how Git stores data as commit snapshots and uses branches to track parallel development lines.
Git Tutorial For Beginners | What is Git and GitHub? | DevOps Tools | DevOps ...Simplilearn
The document provides information on version control systems and Git concepts like distributed version control, forking and cloning repositories, adding collaborators, branching and merging in Git. It includes step-by-step instructions for setting up a Git demo to showcase creating a repository, adding and committing files, connecting to a remote repository on GitHub, forking a project and cloning it locally, creating and switching branches, adding a collaborator, pulling changes, and merging branches.
The document provides an overview of Git and its usage. It introduces Git as a source code management and distributed version control system. Key topics covered include setting up Git, creating local and remote repositories, tracking changes using commits, and collaborating through branches and by pushing to remote repositories. The document also includes exercises for readers to practice common Git commands.
This document provides an introduction to GIT. It describes the advantages of GIT over other version control systems like SVN. It explains the basic data model and architecture of GIT including local repositories, branches, and remote repositories. It also covers common GIT commands for configuring, tracking changes, viewing history, sharing changes with others through pushing and pulling. Finally, it provides some tips for using GIT aliases, auto-completion, and external diff/merge tools.
Version control systems track changes to source code over time by keeping a complete history of file versions in a database. Version control provides benefits like a change history, branching and merging, and traceability. Git is a distributed version control system that allows developers to work offline and collaborate by sharing changes. Developers use branches to work independently on features or bugs, then merge branches to combine changes.
Git is a distributed version control system that was created by Linus Torvalds as an improvement over centralized systems like Subversion; it works by tracking changes to files and committing snapshots of changes locally or to a remote server, and has a flexible branching workflow that allows users to work independently and merge changes together. The document provides an introduction to basic Git concepts, commands, and workflows for versioning code and collaborating through branching and merging changes.
Git is a distributed version control system that allows users to track changes to files and collaborate on projects. It can work locally on a user's machine without needing to be connected to the internet. Users can install Git, initialize local repositories, add and commit files, and push changes to remote repositories hosted on services like GitHub. Git provides commands to view file histories, compare changes between versions, and merge code from different branches.
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.
After talking to several Drupal followers during our last meetup, I realised quite a few people still don't employ version control.
I strongly consider this best practice when building a site, and thought it would be a good opportunity to go over its importance and how you can make it work for you.
Git offers several advantages:
• It's super fast
• It's easy.
• And no you don't need to be familiar with Command Line code (there are several great GUI's out there).
GIT Version Control works by keeping track of all successive changes you make to a site.
The biggest advantage of this is easily undoing any mistakes you might make along the way.
It's a great feeling to know Version Control has your back that you can roll back if something goes catastrophically wrong.
It's also a big bonus in collaborative development.
As soon as more than one person works on a project things get a lot more complicated.
What happens when 2 edits effect the same file? How do you know what's new, what's old and what's changed?
No worries, simply merge the variations and let GIT deal with the rest.
GIT is not just for the developers of this world but can be a life saver for themers, site maintainers and the like.
Most people will admit they should use it, but either don't know how or believe it's hard to integrate.
The reality is that it's actually pretty simple and once you start integrating GIT into your workflow you'll ask yourself "Why the hell did I keep using ftp" - I know I did.
FTP is so yesterday, its slow, it's cumbersome to use and it's a very manual method.
Switch to GIT, start using GIT, and never look back.
Git is a version control system that allows tracking changes in source code. It was created by Linus Torvalds in 2005 to manage changes to the Linux kernel. Git uses a three tree architecture with a repository, staging area, and working directory to track changes. Unlike centralized version control systems, Git is distributed so developers can work independently without internet and merge changes later.
Introduction To Git For Version Control Architecture And Common Commands Comp...SlideTeam
Introduction To Git For Version Control Architecture And Common Commands Complete Deck is an impact virtual tool. Employ our PowerPoint presentation to acquaint your audience with the version management system. This PPT slideshow is ideal to effectively elucidate GIT version control software through the visual aid of industry-best diagrams. Elaborate on the need for GIT by your organization. Consolidate the advantages of the GIT distributed version control application using our PowerPoint layout. Data visualizations featured in this PPT template deck facilitate a better explanation of the GIT architecture. You can also convey the features of this distributed revision control tool. Compile the common commands used in GIT with appreciable ease. Present vital information about the revision control system such as working with remote repositories by the means of our PowerPoint format. This is a must-have virtual solution, especially for upper and mid-level management. So, hit the download icon now and instantly start building an impressive presentation. https://bit.ly/3nMK6c4
Introduction to Git & GitHub.
Agenda:
- What’s a Version Control System?
- What the heck is Git?
- Some Git commands
- What’s about GitHub?
- Git in Action!
GIT is a free and open source distributed version control system that allows developers to work collaboratively without needing centralized connectivity. It provides powerful branching capabilities that allow creating branches cheaply and merging them easily. Common GIT commands include init, clone, status, add, commit, log, remote, fetch, push, and pull. An example scenario demonstrates how multiple developers can clone a remote repository, make changes on their local repos, fetch and push changes between local and remote repos, and merge branches.
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.
This document provides an introduction to using Git version control. It discusses key Git concepts like distributed version control, objects in Git like blobs and trees, and commands like add, commit, branch, merge, rebase, fetch and push. The introduction includes an agenda, sources for further information, and demos several Git workflows and commands.
Git 101 Presentation
The presentation introduces Git version control system including:
[1] An overview of version control systems and the basics of Git such as snapshots, local operations, and three main states of files.
[2] A comparison of features between Git and SVN such as distributed development and branching workflows.
[3] Instructions on setting up Git locally and with GitHub, and basic commands for creating and managing repositories, branches, commits, and merges.
This document provides an overview of GitHub and its technical architecture presented by Chris Wanstrath. Some key points:
- GitHub started as a git hosting site but became a social coding platform where users can see friends' activity and leave comments.
- It uses Ruby on Rails for the main codebase, Resque for background jobs, MySQL for the database, and nginx, unicorn, and memcached.
- Git operations are handled by Grit and communicated to file servers via the BERT-RPC based Smoke protocol.
- Caching, asset optimization, and AJAX loading are used extensively to improve performance. Monitoring tools include Nagios, Resque Web, Haystack, and CollectD.
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.
This document provides a summary of a mini Git tutorial. It begins with an introduction to version control systems and how they allow users to track changes, revert files, and recover from errors. It then explains the basics of Git, including its three main states (committed, modified, staged), how it stores content addressed by SHA-1 hashes, and the local workflow of modifying, staging, and committing files. The document proceeds to cover installing Git, basic configuration, cloning repositories, recording changes, undoing actions, and working with remote repositories hosted online. It concludes by mentioning how Git stores data as commit snapshots and uses branches to track parallel development lines.
Git Tutorial For Beginners | What is Git and GitHub? | DevOps Tools | DevOps ...Simplilearn
The document provides information on version control systems and Git concepts like distributed version control, forking and cloning repositories, adding collaborators, branching and merging in Git. It includes step-by-step instructions for setting up a Git demo to showcase creating a repository, adding and committing files, connecting to a remote repository on GitHub, forking a project and cloning it locally, creating and switching branches, adding a collaborator, pulling changes, and merging branches.
The document provides an overview of Git and its usage. It introduces Git as a source code management and distributed version control system. Key topics covered include setting up Git, creating local and remote repositories, tracking changes using commits, and collaborating through branches and by pushing to remote repositories. The document also includes exercises for readers to practice common Git commands.
This document provides an introduction to GIT. It describes the advantages of GIT over other version control systems like SVN. It explains the basic data model and architecture of GIT including local repositories, branches, and remote repositories. It also covers common GIT commands for configuring, tracking changes, viewing history, sharing changes with others through pushing and pulling. Finally, it provides some tips for using GIT aliases, auto-completion, and external diff/merge tools.
Version control systems track changes to source code over time by keeping a complete history of file versions in a database. Version control provides benefits like a change history, branching and merging, and traceability. Git is a distributed version control system that allows developers to work offline and collaborate by sharing changes. Developers use branches to work independently on features or bugs, then merge branches to combine changes.
Git is a distributed version control system that was created by Linus Torvalds as an improvement over centralized systems like Subversion; it works by tracking changes to files and committing snapshots of changes locally or to a remote server, and has a flexible branching workflow that allows users to work independently and merge changes together. The document provides an introduction to basic Git concepts, commands, and workflows for versioning code and collaborating through branching and merging changes.
Git is a distributed version control system that allows users to track changes to files and collaborate on projects. It can work locally on a user's machine without needing to be connected to the internet. Users can install Git, initialize local repositories, add and commit files, and push changes to remote repositories hosted on services like GitHub. Git provides commands to view file histories, compare changes between versions, and merge code from different branches.
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.
After talking to several Drupal followers during our last meetup, I realised quite a few people still don't employ version control.
I strongly consider this best practice when building a site, and thought it would be a good opportunity to go over its importance and how you can make it work for you.
Git offers several advantages:
• It's super fast
• It's easy.
• And no you don't need to be familiar with Command Line code (there are several great GUI's out there).
GIT Version Control works by keeping track of all successive changes you make to a site.
The biggest advantage of this is easily undoing any mistakes you might make along the way.
It's a great feeling to know Version Control has your back that you can roll back if something goes catastrophically wrong.
It's also a big bonus in collaborative development.
As soon as more than one person works on a project things get a lot more complicated.
What happens when 2 edits effect the same file? How do you know what's new, what's old and what's changed?
No worries, simply merge the variations and let GIT deal with the rest.
GIT is not just for the developers of this world but can be a life saver for themers, site maintainers and the like.
Most people will admit they should use it, but either don't know how or believe it's hard to integrate.
The reality is that it's actually pretty simple and once you start integrating GIT into your workflow you'll ask yourself "Why the hell did I keep using ftp" - I know I did.
FTP is so yesterday, its slow, it's cumbersome to use and it's a very manual method.
Switch to GIT, start using GIT, and never look back.
Git is a version control system that allows tracking changes in source code. It was created by Linus Torvalds in 2005 to manage changes to the Linux kernel. Git uses a three tree architecture with a repository, staging area, and working directory to track changes. Unlike centralized version control systems, Git is distributed so developers can work independently without internet and merge changes later.
Quantified Self gaat een enorme invloed hebben op de manier waarop (klinish) onderzoek gaat verlopen. Van wie is de (big) data? Gaat het nog om causale verbanden of ook nog om correlatie? Wat is nog de rol van de huidige partijen.
WordCamp Philly 2011 - put your business on the webOwen Winkler
The document provides guidance for small business owners on putting their business online, covering topics such as choosing a domain name and email provider, selecting a web host, hiring contractors to build a website, and ensuring the site runs smoothly through ongoing maintenance, security, and marketing. It emphasizes the importance of understanding technical requirements, hiring qualified developers, setting clear expectations and milestones, and focusing on users, content, and analytics for success.
This document provides an overview of basic computer and web security topics. It discusses what security aims to achieve, common threats like stolen passwords, and techniques for protecting against vulnerabilities such as input validation, cross-site scripting, and SQL injection. The document also covers security best practices for Drupal sites, including keeping software updated, using strong and unique passwords, implementing file permissions properly, and performing regular backups. The overall message is that implementing security correctly helps protect users, clients, and systems from potential threats.
The document discusses deployment and change management for software development projects. It defines deployment as delivering changes from a development environment to a production environment, often involving staging for approval. Change management is defined as a formalized process for implementing changes. The document outlines why these processes are important, some common challenges, typical methods and tools used, and barriers to effective change management.
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.
This document provides an introduction and overview of Git. It begins with a brief history of Git's origins with Linux source code management. It then covers key Git concepts like its distributed version control model, advantages like speed and resilience, and some basic commands. The document demonstrates setting up a sample Git repository and making commits. It also discusses branching, tagging, undoing changes, cleaning up repositories, and using remote repositories.
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.
This document provides an introduction to Git and GitHub. It outlines the basics of Git including initializing repositories, tracking changes, branching, merging, and resolving conflicts. It also covers GitHub concepts such as cloning repositories from GitHub to a local machine and pushing/pulling changes between local and remote repositories. The document explains how to collaborate on projects hosted on GitHub using Git.
This document provides an introduction to using version control with Git. It covers why version control is useful, setting up Git locally and on GitHub, creating repositories, committing changes, branching, merging, forking repositories, and making pull requests. The document includes exercises for readers to practice these Git concepts. It aims to explain the key terminology and workflows for getting started with 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
Git is a version control system that allows developers to have multiple versions of codebases and easily revert changes. Github is a website that hosts git repositories on remote servers, facilitating code sharing among teams through a graphical user interface. The document provides instructions on configuring git and connecting it to Github repositories, as well as describing basic workflows for branching, merging, rebasing, and resolving conflicts when integrating changes.
Git is a version control system that allows developers to have multiple versions of codebases and easily revert changes. Github is a website that hosts git repositories on remote servers, facilitating code sharing among teams through a graphical user interface. The document provides instructions on configuring git and connecting it to Github repositories, as well as describing basic workflows for branching, merging, rebasing, and resolving conflicts when integrating changes.
This document provides an introduction to the version control system Git. It defines key Git concepts like the working tree, repository, commit, and HEAD. It explains that Git is a distributed version control system where the full history of a project is available once cloned. The document outlines Git's history, with it being created by Linus Torvalds to replace the commercial BitKeeper tool. It then lists and briefly describes important Git commands for local and collaboration repositories, including config, add, commit, log, diff, status, branch, checkout, merge, remote, clone, push, and pull. Lastly, it covers installing Git and generating SSH keys on Windows for accessing Git repositories.
a way to manage files and directories.
track changes over time.
recall previous versions.
source control is subset of VCS.
sharing on multiple computers
Types of vcs:
Local VCS
Centralized VCS
Distributed VCS
Features of git
commands in git
Simple introduction for development teams familiar with Subversion.
Internal presentation licensed as CC-BY-NC-SA. Attribute to this URL or http://fittl.com/ if you re-publish, do *NOT* use commercially.
Git is a version control system that tracks changes to files and allows multiple versions of files to exist. It is installed locally on a user's computer and tracks changes made to files. GitHub is a cloud-based hosting service that allows users to host Git repositories remotely and provides a web interface to view repositories. By pushing repositories to GitHub, users can easily share codebases with teams and create an online portfolio of their work.
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.
GitHub is a web-based hosting service for version control using git. It is mostly used for computer code. It offers all of the distributed version control and source code management (SCM) functionality of Git as well as adding its own features. It provides access control and several collaboration features such as bug tracking, feature requests, task management, and wikis for every project
3. TEXT EDITOR AND SHELL
Some Editors The Shell
Sublime Text 2 Git Bash
Komodo Edit Terminal
Coda (Mac) ssh
Text Wrangler (Mac)
PSPad (Win)
TextEdit (Win)
5. MARKDOWN QUICK GUIDE
# Level 1 Header (h1) This is *italic*. (em)
## Level 2 Header (h2) This is **bold**. (strong)
##### Level 5 Header (h5)
This links to
Line breaks must have [Google](http://google.com)
two spaces at the end of the line.
* First Item
Paragraphs are separated by a blank line. * Second Item
* Third Item
Indent code blocks
with four spaces!
8. TODAY’S PLAN
1. Basics of SCM
2. Starting a Project
3. Branching and Experimentation
4. GitHub and Remotes
5. Conflict Resolution
6. (Maybe) Using Submodules
11. WHAT IS SCM?
Revision control, also known as version
control and source control is the management of
changes to documents, computer programs, large web
sites, and other collections of information.
~ Wikipedia
20. COMMANDS YOU SHOULD KNOW
ls List the contents of a directory
ls -la List ALL the contents of a directory (hidden files, times, sizes)
cd xx Change to the directory “xx”
cd .. Change to the directory above this one
cd ~ Change to your home directory
cd / Change to the directory at the root of your computer
mkdir Make a directory
pwd -P Show the full path of the current directory
[letter][tab] Autocomplete or show all possibilities
[up-arrow] Use the last command in your history
21. OTHER USEFUL COMMANDS
[Ctrl]+R Search for a previously used command
history List the last 100 or so commands you used
alias l="ls -la" Assign the command “l” to do “ls -la”
mv xx yy Rename/move the file “xx” as “yy”
rm xx Delete the file named “xx”
rmdir xx Delete the empty directory named “xx”
22. LET’S MAKE A FILE
Step 1 Step 2
• Change to the user directory • Find the directory you created in
• Make a directory for this class Finder/Explorer
• Change to the class directory • Create a file called
“contributors.txt”
• Create a directory called “names”
• Edit that file in your editor
• Change to that directory
• Add your name to the file
Do not create the directory
using Finder/Explorer/your
editor!
26. CREATE A REPO
Configure Git Global Settings
• Set your git username
git config --global user.name "github-user-name"
• Set your git email address
git config --global user.email "github-email“
• Set your git editor
Mac: git config --global core.editor "nano"
Windows: Use GitPad
Procedure
• Change to the working directory
• Initialize the repo
git init
27.
28. GIT STATUS
Files can have (in general) 4 states:
• Untracked
• Tracked
• Changed
• Staged
29.
30. GIT ADD/STAGE
We need a way to stage things to be committed.
Committing is an “all at once” action.
Procedure
• Add the contributors.txt file to stage it.
git add contributors.txt
• Check the status of the working directory.
git status
31.
32. COMMIT
Commit changes to the repo.
All staged changes are committed at once.
Every commit is stored in the repo with a “hash”.
Procedure
• Commit all staged changes
git commit
33.
34. LET’S MAKE A CHANGE
Procedure
• Get neighbor’s name and why they’re here
• Add neighbor’s name to your editor (It’s still open, right?)
• Save the file with the added name
• Check the status of your working directory
git status
• Add the file to be staged
git add contributors.txt
• commit the changes to your repo
git commit
36. GIT STASH
Stash is the coolest feature ever.
Stash allows you to make other changes mid-change.
Procedure
• While you still have changes… DO NOT COMMIT!
• Instead, stash your changes
git stash
• Then make your change, add, and commit as normal
git add; git commit
• Then pop your change off the stash
git stash pop
38. GIT DIFF
For when you ask yourself,
Hey, wait a minute, what did I change? ?
Procedure
• Use Diff to see what is currently changed, but not yet staged
git diff
• Use Diff to see what is staged, but not yet committed
git diff –cached
• Use Diff to see the differences between your working copy
and the last commit
git diff HEAD
39.
40.
41. GIT LOG
Use the log to see what you and others have been adding to your repo.
Procedure
• Use git log to see all changes in your current branch
git log
• Use --oneline to see each change in the log on one line
git log –oneline
• Use the hashes shown in the log to get the diff between two commits
git diff
44. GIT REBASE
This is the “What the heck?” git command.
Rebase allows you to combine a bunch of commits into one that makes you
look less like a freakish commit-crazy idiot.
Procedure
• Use rebase to interactively select from the last 5 small commits
to combine into one big commit
git rebase –I HEAD~5
47. BRANCHING
Branching allows you to get experimental.
You can leave the state of master alone, and work solely on your branch.
Process
• Create a new branch
git branch markdownlist
• Checkout the branch you want to work on
git checkout markdownlist
• OR Create a new branch and switch to using it all in one step
git checkout -b markdownlist
• Then list the branches that are available
git branch
git branch -v
51. SWITCHING BETWEEN
BRANCHES
Branches track their own change history.
Switching between branches changes
only the unmodified, tracked files in your working copy.
Procedure
• Check with branch you are on
git status
• Checkout the master branch
git checkout master
• Verify that you’re on the master branch
git status
52.
53. REINTEGRATING BRANCHES
If the changes in a branch need to be copied into the master branch, they
should be merged.
Merging is usually a scary word.
Procedure
• Checkout the branch that the new code should be moved to
git checkout master
• Merge the branch into the current branch
git merge markdownlist
57. TAGGING
Tagging marks a specific commit with a name, and optionally annotates it.
Procedure
• Use git tag to create a lightweight tag of the current branch at HEAD
git tag version1
• OR, Use the -a flag to annotate the tag
git tag -a version 1 -m "My message"
• Use git show to see the commit of the tag
git show version1
60. SSH KEYPAIRS
SSH is the method Github uses to securely exchange data.
Public Keys are the means that Github uses to authenticate.
We must create a key pair to authenticate ourselves to Github.
65. INITIALIZE A REPO FROM
SCRATCH ON GITHUB
Using the instructions to get a repo from Github.
Procedure
• Create the repo on Github
• Follow the instructions to create an empty repo
git init; git add; git commit
• Connect the repo to Github
git remote add origin
git@github.com:ringmaster/scm.git
• Push the repo to Github
git push –u origin master
66.
67.
68.
69. GIT PUSH
After you’ve completed a commit that you want to share,
push your commits to the remote repository.
Procedure
• Finalize any commits (modified or untracked files won’t be pushed!)
• Execute git push on your repo
git push origin master
70.
71. GIT PULL
When you want to update your working copy from the remote repository,
use git pull.
Procedure
• Commit or stash any changes (git won’t let you pull over modified files!)
• Execute git pull on your repo
git pull origin master
72.
73. ADDING A NEW REMOTE
Let’s try creating a new repo on Github for our contributors.txt file repo, and
then pushing to that remote.
Procedure
• Create a new repo on Github
• Add the repo URL (ssh) as a remote on the existing working copy
git remote add origin
git@github.com:ringmaster/contrib.git
• Push the repo to Github
git push –u origin master
76. CLONING
When there is an existing repo on Github that you would like to work on as
your working copy, you clone it.
Procedure
• Copy the git URL from the Github page (use the ssh version)
• Execute git clone where you want to create your new working copy
git clone git@github.com:ringmaster/fob.git
80. OWEN’S IMMUTABLE
LAWS OF SCM
• If you run blame, you’re most likely to find that you’re the one at fault.
• Commit whenever you feel like you’ve reached a point that you’re
complete, even (especially) if you might immediately rewrite the whole
thing.