Muutke küpsiste eelistusi

E-raamat: Learn Git in a Month of Lunches

4.09/5 (88 hinnangut Goodreads-ist)
  • Formaat: 376 pages
  • Ilmumisaeg: 01-Sep-2015
  • Kirjastus: Manning Publications
  • Keel: eng
  • ISBN-13: 9781638353492
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 36,38 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
Learn Git in a Month of LunchesSuurem pilt
  • Formaat: 376 pages
  • Ilmumisaeg: 01-Sep-2015
  • Kirjastus: Manning Publications
  • Keel: eng
  • ISBN-13: 9781638353492
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

DESCRIPTION

Git has emerged as the source code control system preferred by distributed development teams. Its unique decentralized architecture and lightning-fast branching allow users to concentrate on code instead of tedious admin tasks. While Git can appear to be a diverse and sprawling beast, there are a few essential concepts and techniques required to get the most out of it. This book helps build the skills needed to use Git effectively in day-to-day dev tasks.

 





Learn Git in a Month of Lunches introduces the discipline of source code control using Git. Whether a newbie or a busy pro moving source control to Git, readers will appreciate how this book concentrates on the components of Git that are used every day. In easy-to-follow lessons designed to take an hour or less, readers can dig into Git's distributed collaboration model, along with core concepts like committing, branching, and merging. Instead of a shallow introduction to Git's massive surface area, theyll find a road map to the commands and processes needed to be instantly productive.

 

KEY SELLING POINTS









Starts from square oneno experience required

Provides a road map to essential commands and processes





Easy-to-follow lessons taking an hour or less to complete





 

AUDIENCE

This book is aimed at computer professionals of all levelsboth beginners of source code control and newcomers to the Git version control system

 

ABOUT THE TECHNOLOGY

Git is the extremely popular version control system that has taken the open source community by storm. Its designed for speed and efficiency and many open source projects have switched to using Gitthe popularity of GitHub and its "social coding" cannot be denied.
Preface xvii
About this Book xix
Acknowledgments xxii
1 Before you begin
1(7)
1.1 What makes Git so special?
1(2)
1.2 Is this book for you?
3(1)
1.3 How to use this book
3(1)
1.4 Installing Git
4(1)
1.5 Your learning path
5(2)
1.6 Online resources
7(1)
1.7 Being immediately effective
7(1)
2 An overview of Git and version control
8(17)
2.1 Version control concepts
8(6)
Version control for the software developer
8(1)
Version control for the organization
9(1)
What is a repository?
10(1)
What is a commit?
11(1)
What is a branch?
12(2)
2.2 Git's key features
14(3)
Distributed repositories
15(1)
Fast branching
16(1)
The staging area
17(1)
2.3 A quick tour of Git
17(7)
Using the GUI to tour a Git repository
18(3)
Using the command line to tour a Git repository
21(3)
2.4 Version control terminology
24(1)
3 Getting oriented with Git
25(11)
3.1 Getting set up
25(2)
3.2 Using commands
27(3)
Git command-line syntax
27(1)
Common commands
28(2)
3.3 Improving command-line efficiency
30(1)
3.4 Using Git help
31(2)
3.5 Controlling long output with a pager
33(1)
3.6 Lab
34(1)
3.7 Further exploration
34(1)
3.8 Commands in this chapter
35(1)
4 Making and using a Git repository
36(11)
4.1 Understanding repository basics
36(1)
4.2 Creating a new repository with git init
37(2)
4.3 Tracking files with git status and git add
39(3)
Using git status to check your repository state
39(2)
Using git add to add a file to your repository
41(1)
4.4 Committing files with git commit
42(2)
4.5 Viewing the repository with git log and ls-files
44(1)
4.6 Lab
45(1)
4.7 Commands in this chapter
46(1)
5 Using Git with a GUI
47(14)
5.1 Starting Git GUI
47(2)
Starting Git GUI in Windows
48(1)
5.2 Creating a repository with Git GUI
49(2)
5.3 Adding a file into the repository via Git GUI
51(6)
5.4 Looking at your history
57(1)
5.5 Lab
58(1)
5.6 Further exploration
59(1)
Other GUIs for Git
59(1)
Tcl, Tk, and Wish
59(1)
5.7 Commands in this chapter
60(1)
6 Tracking and updating files in Git
61(15)
6.1 Making simple changes
61(4)
Creating a new repository
61(1)
Telling Git about changes
62(1)
Seeing what's different
63(1)
Adding and committing changes to the repo
64(1)
6.2 Thinking about git add
65(7)
An analogy to introduce the staging area
65(1)
Adding changes to the staging area
66(1)
Updating the staging area
66(1)
Understanding the staging area
67(3)
Committing changes
70(2)
6.3 Adding multiple files
72(2)
6.4 Lab
74(1)
Understanding command-line nuances
74(1)
Getting out of trouble
74(1)
Adding your own file
74(1)
6.5 Further exploration
74(1)
6.6 Commands in this chapter
75(1)
7 Committing parts of changes
76(22)
7.1 Deleting files from Git
76(2)
7.2 Renaming files in Git
78(3)
7.3 Adding directories into your repository
81(2)
7.4 Adding parts of changes
83(13)
Reconsidering the stage analogy
83(1)
Considering when to commit
84(2)
Committing parts of a file by using Git GUI
86(4)
Committing parts of a file using git add p
90(3)
Removing changes from the staging area
93(1)
Resetting a file to the last committed version
94(1)
Understanding consequences of partial commits
95(1)
7.5 Lab
96(1)
Working with multiple hunks
96(1)
Changing your mind with a delete
97(1)
Reading assignments
97(1)
7.6 Commands in this chapter
97(1)
8 The time machine that is Git
98(21)
8.1 Working with git log
98(7)
Working with the SHA1 ID
99(1)
Exploring meta information
100(2)
Using gitk to view the commit history
102(2)
Finding all commits by file
104(1)
Using variations of git log
104(1)
8.2 Making proper commit log messages
105(2)
8.3 Checking out a specific version
107(7)
Understanding HEAD, master, and other names
108(2)
Going back in time with git checkout
110(4)
8.4 Breadcrumbs to previous versions
114(1)
8.5 Lab
115(2)
Viewing history (part 1)
115(1)
Amending commits
116(1)
Using other names
116(1)
Committing while in detached HEAD mode
116(1)
Deleting tags
117(1)
Viewing history (part 2)
117(1)
8.6 Further exploration
117(1)
8.7 Commands in this chapter
117(2)
9 Taking a fork in the road
119(21)
9.1 Introducing branches
119(4)
Creating references
120(1)
Understanding that master is just a convention
121(2)
9.2 When and how to create branches
123(8)
Introducing new code with branches
123(7)
Introducing fixes with branches
130(1)
9.3 Performing other branch operations
131(3)
Branching faster
131(1)
Deleting branches
132(2)
9.4 Switching branches safely
134(2)
Stashing away your work
134(1)
Popping the stash
135(1)
9.5 Lab
136(2)
Using the GUI for branch work
136(1)
Warm-up questions
137(1)
Working on another_fix_branch
137(1)
Viewing branches
138(1)
9.6 Further exploration
138(1)
9.7 Commands in this chapter
139(1)
10 Merging branches
140(20)
10.1 Considering point of view: Traffic merges into us
141(1)
10.2 Performing a merge
141(7)
Starting with at least two branches
141(2)
Checking the difference between two branches
143(1)
Performing the merge
144(2)
Working with a merge commit's parents
146(1)
Performing merges in Git GUI
147(1)
10.3 Handling merge conflicts
148(6)
Understanding differences that Git can't handle
148(2)
Merging files by directly editing conflicting hunks
150(1)
Merging files by using a merge tool
151(3)
Aborting a merge
154(1)
10.4 Performing fast-forward merges
154(3)
Understanding the direct-descendant concept
154(2)
Making a fast-forward merge
156(1)
10.5 Lab
157(1)
10.6 Further exploration
158(1)
Calculating the base of a merge with git merge-base
158(1)
Changing how conflicts are displayed (merge.conflictstyle)
158(1)
Performing octopus merges
158(1)
10.7 Commands in this chapter
159(1)
11 Cloning
160(17)
11.1 Cloning: making copies locally
160(7)
Using git clone
161(2)
Viewing branches in your clone
163(3)
Checking out branches
166(1)
11.2 Working with the bare directory
167(6)
Examining Git repository files
168(1)
Creating bare directories with git clone
168(2)
Cloning from bare directories
170(3)
11.3 Listing files in the repo by using git ls-tree
173(1)
11.4 Lab
174(1)
11.5 Further exploration
175(1)
11.6 Commands in this chapter
176(1)
12 Collaborating with remotes
177(15)
12.1 Remotes are distant places
177(7)
Analyzing a clone's origin (git remote)
179(1)
Renaming a remote
180(2)
Adding a remote
182(2)
12.2 Interrogating a remote
184(4)
12.3 Getting a clone from somewhere remote
188(1)
12.4 Lab
189(1)
Exploring your math.github clone
189(1)
Making remotes manually
189(1)
Using other git remote subcommands
190(1)
Creating clones with Git GUI
190(1)
Accessing another remote URL
190(1)
12.5 Further exploration
190(1)
12.6 Commands in this chapter
191(1)
13 Pushing your changes
192(22)
13.1 Pushing sends changes to a remote
193(7)
Permissions are required
193(1)
Pushing requires a branch and a remote
194(2)
Verifying a successful git push
196(4)
13.2 Understanding push conflicts
200(2)
13.3 Pushing branches
202(4)
13.4 Deleting branches on the remote
206(2)
13.5 Pushing and deleting tags
208(1)
13.6 Configuring simple pushes
209(1)
13.7 Lab
210(1)
13.8 Further exploration
211(1)
13.9 Commands in this chapter
212(2)
14 Keeping in sync
214(25)
14.1 Completing the cycle of collaboration
214(4)
14.2 Using git pull: a two-part operation
218(7)
Fetching files from a remote repository (git fetch)
219(5)
Merging two branches (git merge)
224(1)
14.3 Merging a pull
225(10)
Clean merge
226(1)
Clean merge with nonautomatic commit
227(3)
Clean merge with automatic commit
230(1)
Conflicted merges
231(4)
14.4 Restricting pulls to fast-forwards only
235(1)
14.5 Using git fetch and merge instead of pull
236(1)
14.6 Lab
237(1)
14.7 Commands in this chapter
238(1)
15 Software archaeology
239(22)
15.1 Understanding git log
239(9)
Reviewing the basics of git log
239(2)
Limiting the display of commits
241(3)
Seeing differences with git log
244(2)
Using git name-rev to name commits
246(2)
15.2 Understanding gitk view configurations
248(3)
Showing only specific branches in gitk
248(2)
Working with simplified views
250(1)
15.3 Studying files
251(4)
Finding files of interest (git grep)
251(1)
Examining the history of one file
252(3)
15.4 Finding which revision updated a specific line of code
255(2)
Running git blame as a GUI
255(2)
Using git blame on the command line
257(1)
15.5 Leaving messages for those who follow
257(1)
15.6 Lab
258(1)
15.7 Further exploration
258(2)
15.8 Commands in this chapter
260(1)
16 Understanding git rebase
261(18)
16.1 Examining two git rebase use cases
262(2)
Keeping up with the upstream by using git rebase
262(1)
Cleaning up history by using git rebase
263(1)
16.2 Examining use case 1: keeping up with the upstream
264(3)
16.3 Using git reflog and git reset to revert your repo
267(3)
16.4 Examining use case 2: cleaning up history
270(5)
16.5 Lab
275(1)
16.6 Further exploration
276(2)
Cherry picking
276(1)
Commit deleting
277(1)
16.7 Commands in this chapter
278(1)
17 Workflows and branching conventions
279(14)
17.1 The need for Git conventions
279(2)
Conventions for commits
280(1)
Conventions for pushing code
280(1)
Conventions for branching
281(1)
Conventions for using rebase
281(1)
Conventions for tagging
281(1)
17.2 Two Git workflows
281(1)
17.3 git-flow
282(6)
Making a feature branch
283(3)
Making a release branch
286(2)
17.4 GitHub's flow
288(2)
17.5 Lab
290(1)
17.6 Further exploration
290(2)
17.7 Commands in this chapter
292(1)
18 Working with GitHub
293(18)
18.1 Understanding GitHub basics
293(7)
Creating a GitHub account
295(1)
Creating a repository
296(1)
Interacting with the repository
297(3)
18.2 Working with forks
300(3)
Making a fork on GitHub
300(2)
Cloning your fork
302(1)
18.3 Collaborating with pull requests
303(5)
Making a change to your fork
304(1)
Making a pull request
305(2)
Closing the pull request
307(1)
18.4 Lab
308(1)
18.5 Further exploration
309(1)
18.6 Commands in this chapter
310(1)
19 Third-party tools and Git
311(17)
19.1 SourceTree
311(8)
Installing SourceTree
312(1)
Adding a repository into SourceTree
313(2)
Staging a file
315(1)
Tracking underlying Git commands in SourceTree
316(2)
Committing a file in SourceTree
318(1)
History view
318(1)
19.2 Git and the Eclipse IDE
319(7)
Installing Eclipse
320(1)
Adding a repository into Eclipse
320(2)
Staging and committing a file
322(3)
History view
325(1)
19.3 Other third-party tools
326(1)
19.4 Lab
327(1)
20 Sharpening your Git
328(17)
20.1 Introducing the git config command
328(5)
Using Git configuration variables
328(1)
Understanding Git configuration order of precedence
329(2)
Setting Git configurations temporarily
331(1)
Setting Git configurations permanently
332(1)
Resetting Git configurations
333(1)
20.2 Working with Git configuration files
333(3)
Editing Git configuration files
333(1)
Using Git configuration file syntax
334(2)
20.3 Configuring Git's default editor
336(3)
20.4 Configuring files to ignore
339(2)
20.5 Continually learning Git
341(1)
Work on a clone
341(1)
Work with the help
341(1)
Commit often
342(1)
Collaborate
342(1)
20.6 Lab
342(2)
20.7 Commands in this chapter
344(1)
index 345
Rick Umali has been a part of some of Boston's pioneering high-tech companies. He uses Git daily as a developer, and his patient style with presenting complex difficult concepts has made him a valued consultant, trainer, and speaker.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97816383534926e.html
Märksõnad: