This document provides instructions on installing and using basic version control functionality with Git. It covers downloading and verifying Git installation, initializing and committing to a Git repository, viewing commit history and file status, staging and unstaging files, reverting and resetting commits, and tagging commits. The key points are initializing a Git repository, making commits to track changes over time, and various commands to move between commits, view history, and recover from mistakes.
Diapositivas de la charla dada por la gente de uno21.com.ar (@luke_ar y @matitanio) en la UP, el día 21/08/2012. Próximamente en otras universidades :)
My Notes from https://www.codeschool.com/courses/git-realEneldo Serrata
This document contains notes from a Git tutorial on CodeSchool. It outlines the steps and commands for various Git workflows including initializing a repository, staging and committing files, branching and merging, resolving conflicts, tagging releases, and more. The notes are formatted as questions with the corresponding Git commands to perform each task.
This document provides an introduction to Git basics and concepts. It covers version control systems and why distributed version control is useful. It then discusses how Git originated from the Linux kernel project. The document reviews basic Git commands and workflows for setting up a repository, tracking and committing changes. It also covers viewing differences between commits, staging files, and undoing or amending commits. Finally, it discusses sharing repositories remotely including adding remotes, pushing and pulling from remote repositories, and cloning repositories from remote URLs.
Git is a distributed version control system that allows developers to work on codebases simultaneously and merge changes easily. It uses a local repository that can be synced to remote repositories hosted on services like GitHub. Developers clone repositories, make changes on branches, commit locally, and push updates to the remote. Git addresses issues like file locking and enables features like easy merging and reverting changes. Stashing is used to temporarily store uncommitted changes when switching branches. GUI clients and documentation on sites like GitHub help users learn and use Git's powerful capabilities for collaboration.
This document provides instructions for using Git for version control and collaboration. It begins with downloading and installing Git, then configuring basic user settings. It describes initializing and cloning repositories, checking the status of files, and viewing commit logs. The document outlines the basic Git workflow including making changes to files, staging files, and committing changes to the local repository. It also covers pushing and pulling changes to and from remote repositories. Finally, it discusses resolving merge conflicts that can occur when merging branches.
GIT is a distributed version control system that allows for collaboration by keeping track of changes made to source code over time. It keeps snapshots of files and allows users to work offline or disconnected from servers. Unlike centralized systems, GIT considers data as snapshots of files rather than file-based changes, and each user has a full copy of the repository. Users can commit changes to their local repository and then push them to remote repositories. Common commands include add, commit, push, pull, branch, merge, and status.
Git is a distributed version control system that allows users to track changes to files and collaborate with others. It maintains a database of snapshots of files and allows users to commit changes, compare changes between versions, and collaborate through a remote server. Some key aspects of Git include its use of snapshots rather than file differences, its local operations that add data, and its three stages of files - the working directory, staging area, and Git directory.
This document provides an overview of Git, including what it is, its internals, and workflows. Git is a distributed version control system that was designed as a content tracker and file system rather than a traditional SCM. It uses a non-linear development model and stores content in compressed objects including blobs for files, trees for directories, commits for snapshots, and tags for labels. Git allows for distributed and non-linear workflows through features like branching, merging, and rebasing. Common Git workflows include Gitflow and GitHub Flow.
This document provides an overview of version control systems and the basic commands and workflows in Git. It explains that version control systems allow recording changes to files over time so that specific versions can be recalled. It then covers the basic Git commands for recording changes (add, commit), viewing history (log, diff), undoing changes (reset, checkout, amend), and collaborating remotely (push, pull, fetch). It also discusses branching workflows in Git for diverging and merging lines of development.
This document provides an introduction to using Git. Some key points:
- Git is a distributed version control system that is different from CVS/SVN in that nearly every operation is local and Git stores snapshots of files rather than differences.
- The basics of using Git involve recording changes by checking status, adding files, committing changes, and working with remotes like origin.
- Additional topics covered include undoing changes, working with others through branching and merging, tagging versions, and using tools like interactive mode and stashing.
This document outlines the steps to set up Git with Bitbucket on Linux, create a repository, commit and push code, and merge branches. The key steps are:
1. Install Git and configure username and email.
2. Create a repository on Bitbucket and copy the remote repository URL.
3. Initialize a local Git repository, add files, commit changes, and push the code to the remote Bitbucket repository.
4. Pull changes from the remote repository before making new commits to keep the local codebase updated.
This document provides an introduction to using Git. It covers getting Git, creating repositories, staging and committing files, branching, merging, and pushing and pulling changes. The presenter provides exercises for attendees to practice the basic Git commands and workflows. They discuss normal repositories, bare repositories, cloning repositories, viewing logs and commits, configuring user information, amending commits, removing files, branching, merging, pushing changes to a remote repository, and pulling changes from remote.
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.
The document discusses version control and introduces Git as a distributed and centralized version control system. It explains the key properties of Git including being file-based, fast, using checksums, and attention to detail. The document also outlines some of the basic Git commands like add, commit, reset, checkout, diff, and demonstrates other commands like stash, log, show, amend, and branching and merging. It concludes by asking when organizations should switch from SVN to Git version control.
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: An introduction of plumbing and porcelain commandsth507
This document provides an introduction to Git and version control systems. It begins with a poll asking about experience with Git, SVN, and git rebase. It then discusses key Git concepts like distributed version control, the working/staging area, and how Git works. It covers the different types of version control systems and compares centralized and distributed models. The document dives deeper into Git objects like blobs, trees, commits and references. It also distinguishes between low-level plumbing commands and higher-level porcelain commands.
This document provides an introduction to Git and common Git workflows. It discusses what Git is, how it stores data as snapshots rather than file changes, and its advantages as a distributed version control system where the full code history is stored locally. It then demonstrates basic Git commands like init, add, commit, status, branch, merge, tag and working with remotes. Key points covered include initializing and cloning repositories, tracking changes, committing work, branching and merging, and sharing code via remote repositories.
A Beginner's Guide to Git and GitHub, CLI version.
What is Git?
What is Github
Basic commands
Difference between Central and Distributed Version Controlling System
This document provides an overview of Git basics including why Git is useful, how it works, common workflows, branching, merging, rebasing, tagging, bisecting, and using remote repositories on services like GitHub. It explains key Git concepts and commands in an accessible way for those new to version control.
The document discusses the three main states that code can be in with Git: unmodified, staged, and committed. It explains how to use commands like git add, git commit, git status, and git diff to transition code between these states and view changes. It also covers branching, merging, rebasing and rewriting history with commands like git branch, git merge, git rebase and git reset.
GIT is a free and open source distributed version control system that allows users to work locally and share code remotely. It allows creating branches to work on features separately, and merging them together easily. The basic workflow involves initializing a local repository, making commits by adding and saving files, and pushing changes to remote repositories like GitHub to share code. Users can then clone repositories from GitHub to contribute code through pull requests.
This document provides an overview of using Git like a pro. It begins with introducing the author and stating goals of increasing Git understanding, solving cumbersome situations, producing cleaner Git history, and having fun. It then covers key Git concepts like objects, references, branches, HEAD, merging vs rebasing, interactive rebasing, rerere, and how to use reset, reflog, and bisect commands to troubleshoot issues. The document emphasizes hands-on learning through examples and encourages experimenting in the provided Gitlab repository.
This document provides an overview of using Git like a pro. It discusses Git fundamentals like objects, references and branches. It also covers advanced topics such as rebasing, reflogs, resetting and bisecting to find errors. The goals are to increase understanding of Git internals, solve cumbersome situations, produce cleaner histories and have fun.
ConFoo 2016 - Mum, I want to be a Groovy full-stack developerIván López Martín
How many times have you ever heard the term "Full-Stack developer"? In most of the cases it means that you have to be fluent with a backend language, html, javascript, maybe Android or iOS... What if I told you that you can be a Full-Stack developer using only Groovy?
In this talk I'll present the technological stack of Polaromatic, and you'll learn that it's possible to write the whole stack using Groovy. Isn't that amazing?
This document provides an introduction to Git basics and concepts. It covers version control systems and why distributed version control is useful. It then discusses how Git originated from the Linux Kernel project. The document reviews basic Git commands and workflows for setting up a repository, tracking and committing changes. It also covers viewing differences between commits, staging files, and undoing or amending commits. Finally, it discusses sharing repositories remotely including adding remotes, pushing and pulling from remote repositories, and cloning repositories from remote URLs.
Git is a version control system that allows tracking changes to files. It works by taking snapshots of files and storing reference hashes locally. There are three main stages - modified, staged, and committed. Git recommends following a workflow that involves making changes on a development branch, testing, merging to master, and pushing to a remote repository. Common commands include git add to stage changes, git commit to commit them locally, and git push to push to a remote. Branches allow parallel development, and git merge is used to integrate branches.
This document provides an overview of Git, including what it is, its internals, and workflows. Git is a distributed version control system that was designed as a content tracker and file system rather than a traditional SCM. It uses a non-linear development model and stores content in compressed objects including blobs for files, trees for directories, commits for snapshots, and tags for labels. Git allows for distributed and non-linear workflows through features like branching, merging, and rebasing. Common Git workflows include Gitflow and GitHub Flow.
This document provides an overview of version control systems and the basic commands and workflows in Git. It explains that version control systems allow recording changes to files over time so that specific versions can be recalled. It then covers the basic Git commands for recording changes (add, commit), viewing history (log, diff), undoing changes (reset, checkout, amend), and collaborating remotely (push, pull, fetch). It also discusses branching workflows in Git for diverging and merging lines of development.
This document provides an introduction to using Git. Some key points:
- Git is a distributed version control system that is different from CVS/SVN in that nearly every operation is local and Git stores snapshots of files rather than differences.
- The basics of using Git involve recording changes by checking status, adding files, committing changes, and working with remotes like origin.
- Additional topics covered include undoing changes, working with others through branching and merging, tagging versions, and using tools like interactive mode and stashing.
This document outlines the steps to set up Git with Bitbucket on Linux, create a repository, commit and push code, and merge branches. The key steps are:
1. Install Git and configure username and email.
2. Create a repository on Bitbucket and copy the remote repository URL.
3. Initialize a local Git repository, add files, commit changes, and push the code to the remote Bitbucket repository.
4. Pull changes from the remote repository before making new commits to keep the local codebase updated.
This document provides an introduction to using Git. It covers getting Git, creating repositories, staging and committing files, branching, merging, and pushing and pulling changes. The presenter provides exercises for attendees to practice the basic Git commands and workflows. They discuss normal repositories, bare repositories, cloning repositories, viewing logs and commits, configuring user information, amending commits, removing files, branching, merging, pushing changes to a remote repository, and pulling changes from remote.
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.
The document discusses version control and introduces Git as a distributed and centralized version control system. It explains the key properties of Git including being file-based, fast, using checksums, and attention to detail. The document also outlines some of the basic Git commands like add, commit, reset, checkout, diff, and demonstrates other commands like stash, log, show, amend, and branching and merging. It concludes by asking when organizations should switch from SVN to Git version control.
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: An introduction of plumbing and porcelain commandsth507
This document provides an introduction to Git and version control systems. It begins with a poll asking about experience with Git, SVN, and git rebase. It then discusses key Git concepts like distributed version control, the working/staging area, and how Git works. It covers the different types of version control systems and compares centralized and distributed models. The document dives deeper into Git objects like blobs, trees, commits and references. It also distinguishes between low-level plumbing commands and higher-level porcelain commands.
This document provides an introduction to Git and common Git workflows. It discusses what Git is, how it stores data as snapshots rather than file changes, and its advantages as a distributed version control system where the full code history is stored locally. It then demonstrates basic Git commands like init, add, commit, status, branch, merge, tag and working with remotes. Key points covered include initializing and cloning repositories, tracking changes, committing work, branching and merging, and sharing code via remote repositories.
A Beginner's Guide to Git and GitHub, CLI version.
What is Git?
What is Github
Basic commands
Difference between Central and Distributed Version Controlling System
This document provides an overview of Git basics including why Git is useful, how it works, common workflows, branching, merging, rebasing, tagging, bisecting, and using remote repositories on services like GitHub. It explains key Git concepts and commands in an accessible way for those new to version control.
The document discusses the three main states that code can be in with Git: unmodified, staged, and committed. It explains how to use commands like git add, git commit, git status, and git diff to transition code between these states and view changes. It also covers branching, merging, rebasing and rewriting history with commands like git branch, git merge, git rebase and git reset.
GIT is a free and open source distributed version control system that allows users to work locally and share code remotely. It allows creating branches to work on features separately, and merging them together easily. The basic workflow involves initializing a local repository, making commits by adding and saving files, and pushing changes to remote repositories like GitHub to share code. Users can then clone repositories from GitHub to contribute code through pull requests.
This document provides an overview of using Git like a pro. It begins with introducing the author and stating goals of increasing Git understanding, solving cumbersome situations, producing cleaner Git history, and having fun. It then covers key Git concepts like objects, references, branches, HEAD, merging vs rebasing, interactive rebasing, rerere, and how to use reset, reflog, and bisect commands to troubleshoot issues. The document emphasizes hands-on learning through examples and encourages experimenting in the provided Gitlab repository.
This document provides an overview of using Git like a pro. It discusses Git fundamentals like objects, references and branches. It also covers advanced topics such as rebasing, reflogs, resetting and bisecting to find errors. The goals are to increase understanding of Git internals, solve cumbersome situations, produce cleaner histories and have fun.
ConFoo 2016 - Mum, I want to be a Groovy full-stack developerIván López Martín
How many times have you ever heard the term "Full-Stack developer"? In most of the cases it means that you have to be fluent with a backend language, html, javascript, maybe Android or iOS... What if I told you that you can be a Full-Stack developer using only Groovy?
In this talk I'll present the technological stack of Polaromatic, and you'll learn that it's possible to write the whole stack using Groovy. Isn't that amazing?
This document provides an introduction to Git basics and concepts. It covers version control systems and why distributed version control is useful. It then discusses how Git originated from the Linux Kernel project. The document reviews basic Git commands and workflows for setting up a repository, tracking and committing changes. It also covers viewing differences between commits, staging files, and undoing or amending commits. Finally, it discusses sharing repositories remotely including adding remotes, pushing and pulling from remote repositories, and cloning repositories from remote URLs.
Git is a version control system that allows tracking changes to files. It works by taking snapshots of files and storing reference hashes locally. There are three main stages - modified, staged, and committed. Git recommends following a workflow that involves making changes on a development branch, testing, merging to master, and pushing to a remote repository. Common commands include git add to stage changes, git commit to commit them locally, and git push to push to a remote. Branches allow parallel development, and git merge is used to integrate branches.
This document provides an overview of Git basics across multiple levels. At level 1, it introduces Git as a distributed version control system and covers basic Git commands and workflows for setting up a local repository, tracking and committing changes. Level 2 covers additional commands for staging changes, viewing differences, resetting and undoing commits, and sharing a repository by adding a remote and pushing/pulling from it. Remote repositories can be hosted or self-managed, and multiple remotes can be used for environments like production, test, etc. Heroku is also mentioned as a hosting platform that can be set up as a remote.
This document provides an overview of Git commands and workflows:
- It introduces basic Git commands for setting up a local repository, adding and committing files, viewing the status and differences between commits, ignoring files, and more.
- Common workflows are demonstrated including cloning a repository, making changes and committing them locally, and pushing changes to a remote repository.
- More advanced topics are covered like branching, merging, rebasing, resolving conflicts, and using tools to help with these processes.
- Configuration options and tips are provided to customize Git behavior and inspect repositories.
The document provides an introduction and overview of Git. It begins with an introduction of the presenter and then asks poll questions to gauge who is and isn't using source code management systems. It then proceeds to explain what Git is, why it's useful, how to configure and set up a Git repository, how to add and commit changes, create and switch branches, undo changes, and work with remote repositories and resolve conflicts.
The everyday developer's guide to version control with GitE Carter
Git is a distributed version control system that allows developers to track changes in source code. It provides tools to commit changes locally, branch code for parallel development, and collaborate remotely by pushing and pulling changes from a shared repository. Common Git commands include init to create a repository, add and commit to save changes locally, checkout to switch branches, pull to retrieve remote changes, and push to upload local changes. Git helps developers work efficiently by enabling features like branching, undoing mistakes, and viewing the revision history.
This document provides instructions for getting started with Git and GitHub. It outlines the steps to install Git, create a GitHub account, download repositories from GitHub, fork repositories, create branches, create pull requests, and create your own repository. It also explains key Git concepts like version control, local and remote repositories, and the three trees in Git. The document recommends configuring user information and SSH keys. It demonstrates common Git commands like init, status, add, commit, push, pull, clone and checkout. It discusses merge conflicts and meaningful commit messages. Finally, it points to additional resources and provides a practice project for following the GitHub flow.
This document outlines the steps to set up Git with Bitbucket on Linux, create a repository, commit and push code, and merge branches. The key steps are:
1. Install Git and configure username and email.
2. Create a repository on Bitbucket and copy the remote repository URL.
3. Initialize a local Git repository, add and commit files, and push the code to Bitbucket.
4. Pull changes from the remote regularly and use Git commands like merge, rebase, and log to manage branches.
Working with Git – a simple introduction for those used to working with a VCS like Subversion. Explains concepts and shows examples. Feel free to steal slides for your own purposes.
This document provides an introduction and overview of Git and GitHub. It begins with definitions of version control systems and describes the differences between local, centralized, and distributed version control. It then discusses the history and predecessors of Git, including why Git was created. The basics of Git are explained, including setting it up and using common commands like status, add, commit, log, push. It also introduces GitHub and how to use it to host Git repositories.
Git is a version control system that stores snapshots of files rather than tracking changes between file versions. It allows for offline work and nearly all operations are performed locally. Files can exist in three states - committed, modified, or staged. Commits create snapshots of the staged files. Branches act as pointers to commits, with the default branch being master.
This document provides an introduction and overview of using Git for version control. It discusses the basics of version control systems including local version control, centralized version control, and distributed version control. It then walks through setting up Git locally and configuring it, generating SSH keys, creating repositories on GitHub, forking repositories, and basic Git commands and workflows for branching, merging, and working with remotes.
Matt Gauger - Git & Github web414 December 2010Matt Gauger
Git is a version control system that allows developers to track changes to code over time. The document provides a brief introduction to common Git commands like commit, push, pull, and fetch. It also discusses how GitHub builds on Git by providing a platform for hosting projects and collaborating through features like forking, pull requests, and issue tracking. The overall message is that Git and GitHub optimize the development workflow by making it easy to manage changes, work on projects together, and contribute code back to open source projects.
In this slide, I have a fully explanation about what is Git and why use it. I also give a fully explanation about the basic command that mostly use with git.
A short introduction to Git, its primary benefits, and some of the most common Git functions. Presented at the WordPress Grand Rapids meetup December 18, 2014
This document provides an introduction and overview of Git and GitHub. It discusses version control systems and the differences between centralized and distributed version control. Key Git concepts and commands are explained such as configuring Git, creating repositories, adding and committing files, branches, pulling and pushing changes. GitHub is introduced as a platform for hosting Git repositories and collaborating on projects. The document provides instructions for adding collaborators to a GitHub repository.
This document discusses options for building static sites in Ruby. It outlines pros of using Jekyll, such as being well-known and having many plugins, but notes some missing features like asset precompilation and LiveReload. Alternatives to Jekyll are presented, including Middleman and using Sinatra for semi-static sites. The document concludes by thanking the audience.
The document discusses considerations for teaching Ruby on Rails. It notes that students come with a wide range of experience, from true beginners to veteran developers, and the content must be tailored accordingly. Managing student expectations is important, as the hype around Rails can raise expectations that are difficult to meet for beginners. Follow-through after initial lessons is also key to student retention, such as providing a roadmap for further learning.
The document provides an overview of the history and evolution of the Rails web framework from 2006 to 2013. It discusses how Rails initially aimed to make web development "easy" but this led to issues with code quality. It then outlines how conventions and best practices developed over time to structure Rails applications according to the MVC pattern and provide guidance on testing, deployment and other aspects of developing with Rails. The document also notes that many advanced Rails topics were not covered.
Things Future IT Students Should Know (But Don't)bryanbibat
The document discusses what future IT students should know about their field of study and career. It emphasizes that the goal of an IT degree is to learn how to solve human problems using computers. It stresses developing strong problem-solving, communication, and social skills which are more important than specific technical skills. Companies hire based on an individual's ability to solve problems rather than their particular degree. The document advises students to gain experience through projects, explore new technologies, and collaborate with others to prepare for an ever-changing career where adaptability is key.
Things IT Undergrads Should Know (But Don't)bryanbibat
This document provides advice for IT undergrads on things they should know but often don't. It emphasizes that the goal of an IT degree is to learn how to solve human problems using computers. It stresses that the most important language for undergrads to know is SQL. It also notes that employers hire programmers based on their problem-solving skills rather than specific languages. Undergrads should focus on learning fundamentals in college and exploring outside projects as soft skills and adaptability are crucial for success in the real world of constantly changing requirements and impossible deadlines.
From Novice to Expert: A Pragmatic Approach to Learningbryanbibat
From Novice to Expert discusses a pragmatic approach to learning based on the Dreyfus model of skill acquisition. The model describes five stages from novice to expert: novice, advanced beginner, competent, proficient, and expert. As individuals progress through these stages, their decision making shifts from relying solely on rules to developing intuition through experience. The document suggests applying this framework to understand the different needs of developers at various experience levels.
The document discusses Java 8 lambda expressions and how they can be used to filter, map, and reduce collections. It provides examples of filtering a list of employees to only those over age 60, mapping a list of employees to a list of their full names, and reducing a list of employees to calculate their total salary. It notes how lambda expressions allow bulk data operations on collections in a similar manner to SQL queries.
The document provides tips for preparing for a hackathon event called the WebGeek DevCup. It recommends preparing your application framework ahead of time by choosing technologies and setting up modules like authentication, but not completing the full application. It also suggests preparing your development environment, using version control, potentially deploying code, and ensuring good team communication and self-care during the event. The goal is to minimize time spent on setup during the hackathon in order to focus on coding the full application within the limited timeframe.
This document provides tips for using the Vim text editor. It begins with an overview of Vim, describing it as an old but common text editor present on many Unix systems. It then provides 9 tips for using Vim, including using insert mode only when needed, using motions beyond just "i" to enter insert mode, using normal mode for faster navigation, learning text manipulation commands, combining commands with motions, using visual mode to select text, splitting screens and tabs, using plugins, and learning something new each day. It concludes by thanking the reader and providing links to the author's GitHub, Twitter, and personal website.
Ruby and Rails by Example (GeekCamp edition)bryanbibat
The document provides examples of how to perform common programming tasks in Ruby and Ruby on Rails compared to other languages like C#. It shows how Ruby and Rails allow doing more with less code through features like hashes, object oriented programming, metaprogramming, and the MVC framework. The examples include creating hashes, binary trees, class hierarchies, adding methods to numbers, and defining behavior for different instances. It also provides a Rails example for a Twitter clone app and lists resources for learning Ruby and Rails.
This document summarizes several latest trends in web technologies, including cloud computing, HTML5, programming languages like JavaScript and LISP, NoSQL databases, and functional and concurrent languages. Cloud computing allows minimal hardware purchasing through services like AWS while HTML5 expands web capabilities beyond Flash. Programming languages like JavaScript and LISP are being rediscovered for their power and conciseness. NoSQL databases provide an alternative to relational databases for high performance needs.
Virtualization allows users to create virtual machines on their computers. This allows them to run multiple operating systems at once, try out different operating systems without dual booting, and simulate multiple servers or cloud environments. Popular virtualization programs include Oracle VirtualBox and VMware Player, both of which are free to use. Virtualization is useful for web development and getting familiar with cloud computing platforms commonly used in industry.
Developers are knowledge workers, not just encoders or typists. Coding is just a small part of software development, which is primarily about understanding people and business needs. Modern programming requires knowledge of multiple languages and technologies, and developers will use existing packages rather than writing all code themselves.
Latest Trends in Open Source Web Technologiesbryanbibat
The document discusses several latest trends in open source web technologies, including cloud computing, HTML5, programming languages like JavaScript and Lisp, NoSQL databases, and free and open source software gaining more traction. Specifically, it covers how cloud computing can reduce costs by having infrastructure handled by providers like Amazon, HTML5 becoming a replacement for technologies like Flash, and how functional programming languages allow for concise yet powerful code.
Web developers require a passion for continuous learning across the fields of web design, software engineering, domain knowledge, and infrastructure. To succeed, they must stay up-to-date with new tools and methodologies through online resources and by building their skills in languages like HTML, CSS, JavaScript, PHP, and frameworks like Ruby on Rails.
This document provides examples of how to perform common tasks in Ruby and Ruby on Rails using less code compared to other languages like C#. It begins with an overview of Ruby's simplicity and complexity. Several examples are given that show how to create hashes, print output, build binary trees, define classes and modules, call methods, perform calculations, sort and select data, define instance behaviors, and include modules. The document concludes by providing examples of generating a basic Twitter clone app in Rails and scaling it up.
Ruby is a dynamic, open source programming language that is interpreted, object-oriented, and functional. It focuses on simplicity and emphasizes programmer productivity. Ruby on Rails is a web application framework built on Ruby that follows the model-view-controller architectural pattern. It aims to make web development faster and easier through its conventions, including generating scaffolding for basic CRUD operations on models.
This document provides advice for web developers considering freelancing. It recommends (1) thoroughly researching the pros and cons of freelancing and one's skills before starting, (2) creating a detailed plan with short and long-term goals and determining one's strengths and weaknesses, and (3) ensuring financial stability by saving enough money to cover expenses for 6 months in case of inconsistent work.
TrsLabs - Fintech Product & Business ConsultingTrs Labs
Hybrid Growth Mandate Model with TrsLabs
Strategic Investments, Inorganic Growth, Business Model Pivoting are critical activities that business don't do/change everyday. In cases like this, it may benefit your business to choose a temporary external consultant.
An unbiased plan driven by clearcut deliverables, market dynamics and without the influence of your internal office equations empower business leaders to make right choices.
Getting things done within a budget within a timeframe is key to Growing Business - No matter whether you are a start-up or a big company
Talk to us & Unlock the competitive advantage
Generative Artificial Intelligence (GenAI) in BusinessDr. Tathagat Varma
My talk for the Indian School of Business (ISB) Emerging Leaders Program Cohort 9. In this talk, I discussed key issues around adoption of GenAI in business - benefits, opportunities and limitations. I also discussed how my research on Theory of Cognitive Chasms helps address some of these issues
Mobile App Development Company in Saudi ArabiaSteve Jonas
EmizenTech is a globally recognized software development company, proudly serving businesses since 2013. With over 11+ years of industry experience and a team of 200+ skilled professionals, we have successfully delivered 1200+ projects across various sectors. As a leading Mobile App Development Company In Saudi Arabia we offer end-to-end solutions for iOS, Android, and cross-platform applications. Our apps are known for their user-friendly interfaces, scalability, high performance, and strong security features. We tailor each mobile application to meet the unique needs of different industries, ensuring a seamless user experience. EmizenTech is committed to turning your vision into a powerful digital product that drives growth, innovation, and long-term success in the competitive mobile landscape of Saudi Arabia.
AI Changes Everything – Talk at Cardiff Metropolitan University, 29th April 2...Alan Dix
Talk at the final event of Data Fusion Dynamics: A Collaborative UK-Saudi Initiative in Cybersecurity and Artificial Intelligence funded by the British Council UK-Saudi Challenge Fund 2024, Cardiff Metropolitan University, 29th April 2025
https://alandix.com/academic/talks/CMet2025-AI-Changes-Everything/
Is AI just another technology, or does it fundamentally change the way we live and think?
Every technology has a direct impact with micro-ethical consequences, some good, some bad. However more profound are the ways in which some technologies reshape the very fabric of society with macro-ethical impacts. The invention of the stirrup revolutionised mounted combat, but as a side effect gave rise to the feudal system, which still shapes politics today. The internal combustion engine offers personal freedom and creates pollution, but has also transformed the nature of urban planning and international trade. When we look at AI the micro-ethical issues, such as bias, are most obvious, but the macro-ethical challenges may be greater.
At a micro-ethical level AI has the potential to deepen social, ethnic and gender bias, issues I have warned about since the early 1990s! It is also being used increasingly on the battlefield. However, it also offers amazing opportunities in health and educations, as the recent Nobel prizes for the developers of AlphaFold illustrate. More radically, the need to encode ethics acts as a mirror to surface essential ethical problems and conflicts.
At the macro-ethical level, by the early 2000s digital technology had already begun to undermine sovereignty (e.g. gambling), market economics (through network effects and emergent monopolies), and the very meaning of money. Modern AI is the child of big data, big computation and ultimately big business, intensifying the inherent tendency of digital technology to concentrate power. AI is already unravelling the fundamentals of the social, political and economic world around us, but this is a world that needs radical reimagining to overcome the global environmental and human challenges that confront us. Our challenge is whether to let the threads fall as they may, or to use them to weave a better future.
Procurement Insights Cost To Value Guide.pptxJon Hansen
Procurement Insights integrated Historic Procurement Industry Archives, serves as a powerful complement — not a competitor — to other procurement industry firms. It fills critical gaps in depth, agility, and contextual insight that most traditional analyst and association models overlook.
Learn more about this value- driven proprietary service offering here.
DevOpsDays Atlanta 2025 - Building 10x Development Organizations.pptxJustin Reock
Building 10x Organizations with Modern Productivity Metrics
10x developers may be a myth, but 10x organizations are very real, as proven by the influential study performed in the 1980s, ‘The Coding War Games.’
Right now, here in early 2025, we seem to be experiencing YAPP (Yet Another Productivity Philosophy), and that philosophy is converging on developer experience. It seems that with every new method we invent for the delivery of products, whether physical or virtual, we reinvent productivity philosophies to go alongside them.
But which of these approaches actually work? DORA? SPACE? DevEx? What should we invest in and create urgency behind today, so that we don’t find ourselves having the same discussion again in a decade?
AI EngineHost Review: Revolutionary USA Datacenter-Based Hosting with NVIDIA ...SOFTTECHHUB
I started my online journey with several hosting services before stumbling upon Ai EngineHost. At first, the idea of paying one fee and getting lifetime access seemed too good to pass up. The platform is built on reliable US-based servers, ensuring your projects run at high speeds and remain safe. Let me take you step by step through its benefits and features as I explain why this hosting solution is a perfect fit for digital entrepreneurs.
Dev Dives: Automate and orchestrate your processes with UiPath MaestroUiPathCommunity
This session is designed to equip developers with the skills needed to build mission-critical, end-to-end processes that seamlessly orchestrate agents, people, and robots.
📕 Here's what you can expect:
- Modeling: Build end-to-end processes using BPMN.
- Implementing: Integrate agentic tasks, RPA, APIs, and advanced decisioning into processes.
- Operating: Control process instances with rewind, replay, pause, and stop functions.
- Monitoring: Use dashboards and embedded analytics for real-time insights into process instances.
This webinar is a must-attend for developers looking to enhance their agentic automation skills and orchestrate robust, mission-critical processes.
👨🏫 Speaker:
Andrei Vintila, Principal Product Manager @UiPath
This session streamed live on April 29, 2025, 16:00 CET.
Check out all our upcoming Dev Dives sessions at https://community.uipath.com/dev-dives-automation-developer-2025/.
Special Meetup Edition - TDX Bengaluru Meetup #52.pptxshyamraj55
We’re bringing the TDX energy to our community with 2 power-packed sessions:
🛠️ Workshop: MuleSoft for Agentforce
Explore the new version of our hands-on workshop featuring the latest Topic Center and API Catalog updates.
📄 Talk: Power Up Document Processing
Dive into smart automation with MuleSoft IDP, NLP, and Einstein AI for intelligent document workflows.
UiPath Community Berlin: Orchestrator API, Swagger, and Test Manager APIUiPathCommunity
Join this UiPath Community Berlin meetup to explore the Orchestrator API, Swagger interface, and the Test Manager API. Learn how to leverage these tools to streamline automation, enhance testing, and integrate more efficiently with UiPath. Perfect for developers, testers, and automation enthusiasts!
📕 Agenda
Welcome & Introductions
Orchestrator API Overview
Exploring the Swagger Interface
Test Manager API Highlights
Streamlining Automation & Testing with APIs (Demo)
Q&A and Open Discussion
Perfect for developers, testers, and automation enthusiasts!
👉 Join our UiPath Community Berlin chapter: https://community.uipath.com/berlin/
This session streamed live on April 29, 2025, 18:00 CET.
Check out all our upcoming UiPath Community sessions at https://community.uipath.com/events/.
TrustArc Webinar: Consumer Expectations vs Corporate Realities on Data Broker...TrustArc
Most consumers believe they’re making informed decisions about their personal data—adjusting privacy settings, blocking trackers, and opting out where they can. However, our new research reveals that while awareness is high, taking meaningful action is still lacking. On the corporate side, many organizations report strong policies for managing third-party data and consumer consent yet fall short when it comes to consistency, accountability and transparency.
This session will explore the research findings from TrustArc’s Privacy Pulse Survey, examining consumer attitudes toward personal data collection and practical suggestions for corporate practices around purchasing third-party data.
Attendees will learn:
- Consumer awareness around data brokers and what consumers are doing to limit data collection
- How businesses assess third-party vendors and their consent management operations
- Where business preparedness needs improvement
- What these trends mean for the future of privacy governance and public trust
This discussion is essential for privacy, risk, and compliance professionals who want to ground their strategies in current data and prepare for what’s next in the privacy landscape.
#StandardsGoals for 2025: Standards & certification roundup - Tech Forum 2025BookNet Canada
Book industry standards are evolving rapidly. In the first part of this session, we’ll share an overview of key developments from 2024 and the early months of 2025. Then, BookNet’s resident standards expert, Tom Richardson, and CEO, Lauren Stewart, have a forward-looking conversation about what’s next.
Link to recording, transcript, and accompanying resource: https://bnctechforum.ca/sessions/standardsgoals-for-2025-standards-certification-roundup/
Presented by BookNet Canada on May 6, 2025 with support from the Department of Canadian Heritage.
#StandardsGoals for 2025: Standards & certification roundup - Tech Forum 2025BookNet Canada
Git Basics (Professionals)
1. Version Control
with Git
DevCon Git Code Camp for Professionals
15 March 2014
http://devcon.ph/events/git-code-camp-for-professionals
2. Coverage
This workshop will cover the basics of Git
and how to integrate Git and Github into
your day-to-day work.
Slides:
https://speakerdeck.com/bryanbibat/git-basics-professionals
27. Create your first repository
$ mkdir devcon-git101
$ cd devcon-git101
$ git init
28. Create your first repository
$ mkdir devcon-git101
$ cd devcon-git101
$ git init
29. Create your first repository
$ mkdir devcon-git101
$ cd devcon-git101
$ git init
Here we create a project folder
30. Create your first repository
$ mkdir devcon-git101
$ cd devcon-git101
$ git init … Then we initialize it as a git repository.
31. Create your first repository
$ mkdir devcon-git101
$ cd devcon-git101
$ git init … Then we initialize it as a git repository.
Git can now track the changes inside our
project folder.
32. Create your first commit
First create a file "hello.txt" containing:
Hello
Then run the following commands:
$ git add hello.txt
$ git commit -m "Initial Commit"
34. View the pretty repo history
$ git log --graph --pretty=oneline
(press q to exit)
35. Ah, what the hell...
Windows/Linux:
$ gitk
Mac:
$ gitx
36. Create your second commit
Modify "hello.txt" to add "world":
Hello World!
Then run the following commands:
$ git add hello.txt
$ git commit -m "Make hello.txt more exciting"
42. Initial Commit6fba518
object name
aka object id, commit hash
●
SHA-1 hash / checksum for verifying the integrity of the contents of the commit
●
Calculated based on file contents and metadata like last updated date i.e. yours
will be different
49. Initial Commit
1 file created
6fba518
Make hello.txt more exciting
1 file modified
e642771
Create 2 files in a single commit
2 files created
7c57165
Each commit deals with a set of files
54. File Status
(untracked)
$ git status
# On branch master
# Untracked files:
# (use "git add <file>..." to include in
what will be committed)
#
# animals.txt
nothing added to commit but untracked files
present (use "git add" to track)
56. File Status
(untracked and modified)
$ git status
# On branch master
# Changes not staged for commit:
# (use "git add <file>..." to update what will be committed)
# (use "git checkout -- <file>..." to discard changes in working
directory)
#
# modified: names.txt
#
# Untracked files:
# (use "git add <file>..." to include in what will be committed)
#
# animals.txt
no changes added to commit (use "git add" and/or "git commit -a")
57. File Status
(untracked and staged)
$ git add names.txt
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# modified: names.txt
#
# Untracked files:
# (use "git add <file>..." to include in what will be
committed)
#
# animals.txt
!
58. File Status
(commit staged)
$ git commit -m "Add Janet"
[master 5e545ed] Add Janet
1 file changed, 1 insertion(+)
$ git status
# On branch master
# Untracked files:
# (use "git add <file>..." to include in what will be
committed)
#
# animals.txt
61. Stage a folder
$ git add .
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: animals.txt
# modified: names.txt
#
!
62. Unstage a file
$ git reset HEAD names.txt
Unstaged changes after reset:
M names.txt
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: animals.txt
#
# Changes not staged for commit:
# (use "git add <file>..." to update what will be committed)
# (use "git checkout -- <file>..." to discard changes in working
directory)
#
# modified: names.txt
#
!
63. Unmodify a file
$ git checkout -- names.txt
$ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage)
#
# new file: animals.txt
#
65. Stage and commit
EVERYTHING
(except untracked files)
$ git commit -a -m "Commit unrelated changes.. DON'T DO THIS"
[master 61f1cd8] Commit unrelated changes.. DON'T DO THIS
2 files changed, 4 insertions(+)
create mode 100644 animals.txt
$ git status
# On branch master
nothing to commit, working directory clean
Note: using "-a" will also stage moved and renamed files.
66. Amend last commit
$ git commit -m "Commit unrelated changes... DON'T DO THIS" --amend
[master 3a0eac3] Commit unrelated changes... DON'T DO THIS
2 files changed, 4 insertions(+)
create mode 100644 animals.txt
!
68. Initial Commit6fba518
Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Commit unrelated changes... DON'T DO THIS3a0eac3
69. Initial Commit6fba518
Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Commit unrelated changes... DON'T DO THIS3a0eac3
HEAD
70. Create a reverting commit
$ git revert HEAD --no-edit
[master 2a1b52e] Revert "Commit unrelated changes... DON'T DO THIS"
2 files changed, 4 deletions(-)
delete mode 100644 animals.txt
71. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Commit unrelated changes... DON'T DO THIS3a0eac3
HEAD
72. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
73. Move HEAD to a commit
discarding changes
$ git reset --hard 7c57165
HEAD is now at 7c57165 Create 2 files in a single commit
(You can use the first few characters of the object ID instead of the 40 characters)
74. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
75. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
76. View history
$ git log --graph --pretty=format:'%h %s%d' --all
* 7c57165 Create 2 files in a single commit (HEAD, master)
* e642771 Make hello.txt more exciting
* 6fba518 Initial Commit
or
$ gitk --all
77. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
HEAD
78. Move HEAD to a commit
$ git reset --hard 2a1b52e
HEAD is now at 2a1b52e Revert "Commit unrelated changes... DON'T DO
THIS"
!
79. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
HEAD
80. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
81. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
84. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
85. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
tagging-demo
86. Going back...
$ git reset --hard 7c57165
HEAD is now at 7c57165 Create 2 files in a single commit
!
87. Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
Add Janet5e545ed
Revert "Commit unrelated changes... DON'T
DO THIS"
2a1b52e
HEAD
Commit unrelated changes... DON'T DO THIS3a0eac3
tagging-demo
88. View history
$ git log --graph --pretty=format:'%h %s%d' --all
* 2a1b52e Revert "Commit unrelated changes... DON'T DO THIS" (tagging-demo)
* 3a0eac3 Commit unrelated changes... DON'T DO THIS
* 5e545ed Add Janet
* 7c57165 Create 2 files in a single commit (HEAD, master)
* e642771 Make hello.txt more exciting
* 6fba518 Initial Commit
or
$ gitk --all
102. Summary of Commands
git init - initialize repository
git add - add files/folders to staging
git commit - commit files in staging
git status - view status of repository
git log / gitk - view history of repository
git revert - unstage files
git reset - move HEAD to another commit
git tag - tag a commit
103. Summary of Command
Variations
git commit -a
- auto-stage all deleted, moved, modified
gitk --all / git log --all
- include all branches, tags
git tag -d
- delete tag
115. Initial Commit6fba518
Make hello.txt more excitinge642771
Create 2 files in a single commit7c57165
master end-part1
HEAD
in other version control
systems, master is called
trunk
134. Commit to master
Modify "names.txt" to add "Billy":
Alice
Billy
Bob
Cindy
$ git commit -am "Add Billy"
[master cc3044c] Add Billy
1 file changed, 1 insertion(+)
140. Commit to testing2
Modify "names.txt" to add "Dave":
Alice
Billy
Bob
Cindy
Dave
$ git commit -am "Add Dave"
[testing2 80414cf] Add Dave
1 file changed, 1 insertion(+)
158. Working on two branches
$ git checkout -b merging-demo
Switched to a new branch 'merging-demo'
159. Commit to merging-demo
Modify "names.txt" to remove "Alice":
Billy
Bob
Cindy
Dave
Eve
$ git commit -am "Remove Alice"
[merging-demo 00b26cb] Remove Alice
1 file changed, 1 deletion(-)
160. Commit to merging-demo
Modify "names.txt" to remove "Cindy":
Billy
Bob
Dave
Eve
$ git commit -am "Remove Cindy"
[merging-demo b115e79] Remove Cindy
1 file changed, 1 deletion(-)
161. Switch back to master
$ git checkout master
Switched to branch 'master'
183. Fetching demo
Go back to /devcon-git101 (either open a new terminal/Git Bash
window) and modify "names.txt" to add Greg:
Billy
Bob
Dave
Eve
Greg
$ git commit -am "Add Greg"
[master cf5f902] Add Greg
1 file changed, 1 insertion(+)
192. Shortcut
$ git fetch
$ git merge origin/master
is equivalent to
$ git pull
if you're in master branch.
We'll discuss more of this later.
193. Now that we understand the
basic idea behind remote repos,
let's proceed to Github...
Sign-up at https://github.com
194. Create a repo in Github for
devcon-git101
https://github.com/new
195. Pushing devcon-git101
Go back to devcon-git101 and push it to your new repo
(this uses SSH url, you can use HTTPS)
$ git remote add origin [email protected]:user/devcon-git101.git
$ git push -u origin master
Warning: Permanently added the RSA host key for IP address
'192.30.252.130' to the list of known hosts.
Enter passphrase for key '/c/Users/user/.ssh/id_rsa':
Counting objects: 40, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (24/24), done.
Writing objects: 100% (40/40), 3.41 KiB, done.
Total 40 (delta 3), reused 0 (delta 0)
To [email protected]:user/devcon-git101.git
* [new branch] master -> master
Branch master set up to track remote branch master from origin.
196. git push
Note that "git push" only pushes a single branch.
If you want to push all branches you can use:
$ git push REMOTE --all
If you want to push all tags you can use:
$ git push REMOTE --tags
197. Clone into another folder
$ cd ..
$ git clone [email protected]:user/devcon-git101.git github-git101
Cloning into 'github-git101'...
remote: Counting objects: 40, done.
remote: Compressing objects: 100% (21/21), done.
remote: Total 40 (delta 3), reused 40 (delta 3)
Receiving objects: 100% (40/40), done.
Resolving deltas: 100% (3/3), done.
done.
198. play time
With the cloned folder, you can now play around with certain
collaboration scenarios. For example:
1. Make some changes in /devcon-git101
2. Commit it via "git commit"
3. Push it to the repo at Github via "git push"
4. Go to /github-git101 and pull the changes via "git pull"
199. Want to let someone else push to
your repo?
Go to the repo Settings →
Collaborators and add your friends.
200. Push/Pull
You'll quickly notice that git push only allows
fast-forward changes to be pushed.
In simpler terms, you cannot push until you pull
the latest changes from the remote.
201. pull + rebase
Want to get rid of the distracting merge commits
whenever you pull when you have pending
commits? Tell git to rebase instead of merging:
$ git pull --rebase origin master
202. Github for Windows automatically uses
git pull --rebase + git push when
syncing
203. merge vs rebase
The problem with rebase is that you can overwrite
commits already on the remote repository and this can
affect your team.
That said, people generally use rebase when working
together on a single branch (e.g. git pull --rebase
origin master) and merge when merging branches.
204. Tired of entering your
password?
There are multiple ways to
authenticate users in Git.
Let's discuss the more secure
alternative: via SSH keys.
209. Authentication via SSH Key
(oversimplified)
Client has 2 "keys" Server
private key
public key
210. Authentication via SSH Key
(oversimplified)
Client has 2 "keys"
Server has a list of
authorized keys
private key
public key
211. Authentication via SSH Key
(oversimplified)
Client has 2 "keys"
Server has a list of
authorized keys
private key
public key
First, the public key must be sent to the server securely beforehand.
212. Authentication via SSH Key
(oversimplified)
Client
Server has a list of
authorized keys
private key
public key
Using the private key, client can create a package that
can only be unlocked by the corresponding public key
and only that public key.
213. Authentication via SSH Key
(oversimplified)
Client
Server has a list of
authorized keys
private key
public key
Using the private key, client can create a package that
can only be unlocked by the corresponding public key
and only that public key.
214. Authentication via SSH Key
(oversimplified)
Client
Server has a list of
authorized keys
private key
public key
Using the private key, client can create a package that
can only be unlocked by the corresponding public key
and only that public key.
215. Authentication via SSH Key
(oversimplified)
Client
Server has a list of
authorized keys
private key
public key
Using the private key, client can create a package that
can only be unlocked by the corresponding public key
and only that public key.
doesn't matter if
intercepted since
they still need to
crack it.
216. How to generate your SSH Keys:
https://help.github.com/articles/generating-ssh-keys
Also, follow the steps to add your public
key to Github.
217. If you want to be secure, use a
passphrase.
However, if you're using Windows, you
will need to enter it every time you run
a git command that connects to Github.
218. Fortunately, there is a workaround
that will only require you to enter it
once per session.
http://stackoverflow.com/a/9011152
221. Free Private Repos
Since Github is only free for public repos, you might want to
look into the following to keep your source code private:
Assembla (https://www.assembla.com)
- 1 private repo, limited to 3 collaborators
BitBucket (https://bitbucket.org/)
- Unlimited private repos, limited to 5 collaborators
Github Educational Accounts (https://github.com/edu)
- free accounts for students and teachers
222. Self-Hosted Repos
If you've got spare time and spare servers, you can also host
your own git repositories:
GitLab (https://www.gitlab.com/)
- GitHub clone written in Ruby
GitBucket (https://github.com/takezoe/gitbucket)
- GitHub clone written in Scala
You can also read the docs for other self-hosting options
http://git-scm.com/book/en/Git-on-the-Server
224. Project Workflow
Here's the most basic workflow for working with with others
through version control systems:
1. Double check if the project work e.g. compiles, pages load, etc.
2. Stage and commit your changes.
3. Before pushing, pull changes from the remote project repo. If
there are no changes, skip to step 5.
4. Resolve conflicts, if any, then go back to step 1.
5. Push your changes.
225. Branches + Workflow
There are two main camps in using branches for
projects using Git:
1. Mainline
e.g. git-flow (http://nvie.com/posts/a-successful-git-branching-model/)
2. Trunk-based
e.g. how Github does it (https://gist.github.com/17twenty/6733076)
228. Communicate!
Version control systems aims to improve communication
between team members, not replace it.
Always consult with the other person whenever
you encounter a merge conflict.
229. Broken Builds
To repeat step 1:
1. Double check if the project work e.g. compiles, pages load, etc.
Broken builds are what we call published commits that have
obvious critical, show-stopping bugs.
That said, it's better to delay pushing your commits to spend
more time making sure that the project works rather than waste
everyone's time.
230. Continuous Integration
You can use CI servers to automatically inform you of
broken builds. Most CI servers nowadays support Git
and its post-commit hooks to automatically test on a
push. Some examples:
●
Jenkins Git Plugin
https://wiki.jenkins-ci.org/display/JENKINS/Git+Plugin
●
TeamCity Git docs
http://confluence.jetbrains.com/display/TCD8/Git+(JetBrains)
231. Work in Progress
Avoid publishing half-done work as it can lead to
broken builds.
If you need to push those changes (e.g. you want
a backup), put them in a branch then push that
branch. Or consider using git stash.
241. Summary of Commands
git branch - list, create, or delete branches
git checkout - checkout a branch or a path
git merge - merge two or more branches
git rebase - move commits to the end of a branch
git clone - make a local copy of a repository
git remote - list, create, or delete remote repos
git fetch - retrieve objects/changes from a repository
git pull - fetch + merge or rebase
git push - publish local commits to a remote
242. Summary of Command
Variations
git checkout -b
- create and checkout branch
git remote add
- add a new remote repository to track
git remote rm
- remove remote repository
git pull --rebase
- rebase instead of merge when pulling
243. Commands that I use
everyday
git pull --rebase
git add
git commit -am "blah blah"
gitk / git log / git status / git diff
git push
244. Commands that I use less
often
git clone
git remote add
git remote -v
git checkout <branch>
git rebase <branch> / git merge <branch>
git checkout -- <path>
git reset --hard <hash>
git revert