Aucun appareil Kindle n'est requis. Téléchargez l'une des applis Kindle gratuites et commencez à lire les livres Kindle sur votre smartphone, tablette ou ordinateur.

  • Apple
  • Android
  • Windows Phone
  • Android

Pour obtenir l'appli gratuite, saisissez votre numéro de téléphone mobile.

Prix Kindle : EUR 19,99
TVA incluse

Ces promotions seront appliquées à cet article :

Certaines promotions sont cumulables avec d'autres offres promotionnelles, d'autres non. Pour en savoir plus, veuillez vous référer aux conditions générales de ces promotions.

Envoyer sur votre Kindle ou un autre appareil

Envoyer sur votre Kindle ou un autre appareil

Version Control with Git: Powerful tools and techniques for collaborative software development par [Loeliger, Jon, McCullough, Matthew]
Publicité sur l'appli Kindle

Version Control with Git: Powerful tools and techniques for collaborative software development 2 , Format Kindle

4.5 étoiles sur 5 2 commentaires client

Voir les 2 formats et éditions Masquer les autres formats et éditions
Prix Amazon
Neuf à partir de Occasion à partir de
Format Kindle
"Veuillez réessayer"
EUR 19,99

Descriptions du produit

Présentation de l'éditeur

Get up to speed on Git for tracking, branching, merging, and managing code revisions. Through a series of step-by-step tutorials, this practical guide takes you quickly from Git fundamentals to advanced techniques, and provides friendly yet rigorous advice for navigating the many functions of this open source version control system.

This thoroughly revised edition also includes tips for manipulating trees, extended coverage of the reflog and stash, and a complete introduction to the GitHub repository. Git lets you manage code development in a virtually endless variety of ways, once you understand how to harness the system’s flexibility. This book shows you how.

  • Learn how to use Git for several real-world development scenarios
  • Gain insight into Git’s common-use cases, initial tasks, and basic functions
  • Use the system for both centralized and distributed version control
  • Learn how to manage merges, conflicts, patches, and diffs
  • Apply advanced techniques such as rebasing, hooks, and ways to handle submodules
  • Interact with Subversion (SVN) repositories—including SVN to Git conversions
  • Navigate, use, and contribute to open source projects though GitHub

Détails sur le produit

  • Format : Format Kindle
  • Taille du fichier : 7534 KB
  • Nombre de pages de l'édition imprimée : 456 pages
  • Utilisation simultanée de l'appareil : Illimité
  • Editeur : O'Reilly Media; Édition : 2 (14 août 2012)
  • Vendu par : Amazon Media EU S.à r.l.
  • Langue : Anglais
  • ASIN: B008Y4OR3A
  • Synthèse vocale : Activée
  • X-Ray :
  • Word Wise: Non activé
  • Composition améliorée: Non activé
  • Moyenne des commentaires client : 4.5 étoiles sur 5 2 commentaires client
  • Classement des meilleures ventes d'Amazon: n°20.366 dans la Boutique Kindle (Voir le Top 100 dans la Boutique Kindle)
  • Voulez-vous nous parler de prix plus bas?
    Si vous vendez ce produit, souhaitez-vous suggérer des mises à jour par l'intermédiaire du support vendeur ?


Quels sont les autres articles que les clients achètent après avoir regardé cet article?

click to open popover

Commentaires en ligne

4.5 étoiles sur 5
5 étoiles
1
4 étoiles
1
3 étoiles
0
2 étoiles
0
1 étoile
0
Voir les deux commentaires client
Partagez votre opinion avec les autres clients

Meilleurs commentaires des clients

Format: Broché
Have you heard about Git but not sure what is it? This book will give you nearly complete explanation of what Git is all about. In my personal opinion, one of the best introductions to Git. Ever. The book covers most common topics and does it right. In case you are complete beginner, it provides initial Git setup section. So, be afraid not. If you prefer to use Windows over Linux or OS X, you will be told how to setup things as well. What’s most important is that all the concepts are well illustrated and well explained with pictures and examples. However, sometimes you will have to focus on what you read to get the complete knowledge of the topic. It’s not just that you flip the pages and that’s it. When it comes to scientific jargon I’d say it’s on the moderate level. For readers, having knowledge of the terms related to source management systems would be a plus here, but is not necessary.

Just one warning, in case you are purely Windows user and you have got used to work with GUI only. You will have to go back to CLI while reading this book. I don’t say this is wrong, not at all, but it might be a challenge for some Windows users.
Remarque sur ce commentaire 3 personnes ont trouvé cela utile. Avez-vous trouvé ce commentaire utile ? Oui Non Commentaire en cours d'envoi...
Merci pour votre commentaire.
Désolé, nous n'avons pas réussi à enregistrer votre vote. Veuillez réessayer
Signaler un abus
Par Guy le 20 novembre 2015
Format: Format Kindle Achat vérifié
This is a great detailed book that goes deeply into GIT. It also highlight the complexity of GIT. It might be difficult for begonnets.
Remarque sur ce commentaire Avez-vous trouvé ce commentaire utile ? Oui Non Commentaire en cours d'envoi...
Merci pour votre commentaire.
Désolé, nous n'avons pas réussi à enregistrer votre vote. Veuillez réessayer
Signaler un abus

Commentaires client les plus utiles sur Amazon.com (beta)

Amazon.com: 4.2 étoiles sur 5 54 commentaires
170 internautes sur 175 ont trouvé ce commentaire utile 
3.0 étoiles sur 5 A fully-loaded information train wreck 15 mars 2013
Par Galen Menzel - Publié sur Amazon.com
Format: Broché Achat vérifié
Though more comprehensive than Scott Chacon's Pro Git, this book is a mess. It fails both as a reference and as a tutorial. It's written in a verbose, example-driven style, which dulls its usefulness as a reference; and the authors' ludicrous sense of pacing ruins it as a tutorial.

The chapter that is supposed to serve as an introduction to git (Chapter 3) is a scattershot mishmash of common tasks like executing a commit and once-off configuration commands like setting your commit author information. The common tasks that it covers tend to be covered very, very quickly as more of a teaser for more-complete coverage later in the book. While it's fine to delay full coverage of usage until later, reading only this chapter would leave you totally ill-equipped to do anything useful with git. By contrast, Chapter 2 of Pro Git contains most everything you need to be an autonomous, if somewhat unsophisticated, git user working in a single branch.

Chapter 4, ostensibly about "Basic Git Concepts" (since that is its title), is actually mostly about git internals, and is completely out of place at the beginning of the book. Why are we covering blobs and packfiles before we even cover what a branch is? Does knowing the git write-tree command help me understand how to use git well as a beginner? (And if you're not concerned about beginners, why include information about how to install git?) This is basic stuff, guys: cover the high-level interface first, then cover the low-level commands and internals. Would you start off a Unix tutorial by talking about disk blocks and inodes before covering what a directory is?

This pattern continues throughout the book. The authors are completely tonedeaf to the needs of the learner, and simply stream information out, never seeming to ask themselves if their presentation will create a progressively more effective git user.

Coverage of tags is suprisingly bad (almost nonexistent, in fact).

All that said, this is probably the most-comprehensive book on git available. And the later chapters on advanced manipulations and tips and tricks are good. I give it four stars for content, and dock it a star for its abysmal organization. It's not throw-it-in-a-fire bad, but you're better off reading Pro Git as a tutorial, and referring to the man pages (which are quite good) after that.
6 internautes sur 6 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Outstanding Reference for Git 10 janvier 2015
Par Abel Brown - Publié sur Amazon.com
Format: Broché Achat vérifié
Before my purchase I was trying to figure out if I should by O'Reilly Git or Pro Git. In the end I bought both and am happy that I did. If you really need to choose between the two here is a good reference scenario: at your company you're and another guy are in charge of migrating 20 people from SVN to GIT. Buy two copies of O'Reilly git and 20 copies of Pro Git. If you want to master Git then O'Reilly is where it's at. But if you're simply looking for a definitive guide to quickly get proficient then Pro Git will serve you well (with out all the "under-the-hood fluff").
12 internautes sur 14 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Not a "train wreck" 8 mai 2015
Par Erik Gfesser - Publié sur Amazon.com
Format: Broché Achat vérifié
Solid discussion of Git for someone like me who has primarily been using CVS and SVN (Subversion) throughout their career, and has since started using Git. While I do not view this book as the "train wreck" that the top reviewer here describes, be aware that if you are completely new to version control systems (VCS) you will likely want to look elsewhere (at least for introductory explanations), because the authors jump right into Git usage without first providing much VCS background information.

After a cursory Git introduction, the authors provide what I consider the core of the text (the first 14 chapters of 21), covering installation, how to get started, basic Git concepts, file management, the Git index, commits, branches, diffs, merges, altering commits, the stash, the reflog, remote repositories, repository management, and patches. After this core, the discussion turns to hooks, combining projects, submodule best practices, using Git with SVN repositories, advanced manipulations, tips/tricks/techniques, and use of GitHub (although I decided to skip a couple of these latter chapters, such as the one on hooks, because I do not plan to use this feature in the near future).

Working through this book, I especially appreciated the diagrams (which explain Git objects and commit graphs) and the high number of working examples (of which I recently executed about 90% or so). The diagrams which explain branching and merging are the types of diagrams typical colleagues and I white board with each other to explain a given project state, helping enable both understanding of the material as well as providing future reference for visual depiction.

One of the reasons I decided to go with this book to get more familiar with Git, other than the fact that there are not many Git texts of which to choose in the marketplace, is because it was published relatively recently relative to when I purchased it about a year ago. Unfortunately, a potentially better book called "Pro Git (Second Edition)" that other reviewers have mentioned has since been published, something that happens when a book is not read soon after purchase.

Be aware that while almost every single example that I executed over the course of working through this book ran flawlessly (somewhat of a rarity with technology texts), I did notice on a few occasions that the command line output from a handful of commands was slightly different than what was represented in the material, and I attribute this to a lack of alignment between the Git version that the authors used (1.7.9) and what I used (2.1.4), downloaded as part of Cygwin. However, this aspect did not distract from the material presented by Loeliger and McCullough.

Although the chapter on installation (Chapter 2) does briefly mention the Git version that the authors used, the remainder of the book really does not address this topic apart from a few isolated instances. For example, the chapter on remote repositories (Chapter 12) mentions that differing versions will display a remote-tracking branch differently. When executing another example in the same chapter, I came across a warning that gets displayed when pushing to the depot because the implicit value of "push.default" was changed in Git 2.0 from "matching" to "simple". And although minor, an attempt to clone the 1.5.x branch of SVN referenced in the chapter on using Git with SVN repositories resulted in a "repository moved temporarily" message (the most recent stable version of SVN is currently 1.8.13).

In general, however, this book provides a solid discussion of Git, and these are all but minor annoyances. A review of Git itself is not the purpose of a Git book review, but if you are at a point where you have solely heard about Git from colleagues who recommend that Git should be used because "it's cool" or remark that "all you really need to know are like three commands, don't worry about the other stuff" (I have actually heard developers make these types of comments), diving into Git with regard to what is happening under the covers is arguably the right way to go, and this book can help.
3.0 étoiles sur 5 Not very happy with this book 22 avril 2017
Par Bradley Goodman - Publié sur Amazon.com
Format: Broché Achat vérifié
Not very happy with this book. I found it to immediately confuse me by jumping into very low-level aspects of git without providing a sufficient high-lever understanding or overview. i.e. start with *basic* operations and then get into the lower-level stuff. It seemed to start at the "low-level" stuff and didn't really provide adequate context for it - so it left me confused...
4.0 étoiles sur 5 It's obviously written by brilliant developers for themselves 13 juillet 2014
Par Stephen A. Brandli - Publié sur Amazon.com
Format: Format Kindle Achat vérifié
Git is remarkably innovative and remarkably difficult to use. It's obviously written by brilliant developers for themselves. This book does an excellent job explaining the model that Git presents and the inner workings that implement the model. An understanding of these things is necessary to use Git effectively. A simple explanation of commands would not suffice. (This is not true of all programs. Many can be understood at a surface level with no understanding of the internal moving parts. Not true with Git.)

However, the book is worthless as a reference. Once one has read the book, putting the understanding it gives into action requires other resources. For example, I understood from the book what a symref is, but took some time to figure out the right command to see all tags (which are symrefs) in a remote repository.

I give the book four stars because (a) it does such a good job explaining Git's model and underpinnings, and (b) a full understanding of Git's command structure could be a book in itself. A five star book would add a chapter on the command structure even though it would not contain a full reference.
Ces commentaires ont-ils été utiles ? Dites-le-nous

Où en sont vos commandes ?

Livraison et retours

Besoin d'aide ?