Gebraucht kaufen
EUR 0,78
+ EUR 3,00 Versandkosten
Gebraucht: Sehr gut | Details
Verkauft von betterworldbooks__
Zustand: Gebraucht: Sehr gut
Kommentar: Great condition for a used book! Minimal wear. 100% Money Back Guarantee. Shipped to over one million happy customers. Your purchase benefits world literacy!
Ihren Artikel jetzt
eintauschen und
EUR 0,10 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Dieses Bild anzeigen

Pragmatic Version Control with CVS (Pragmatic Programmers) (Englisch) Taschenbuch – 30. September 2003

1 Kundenrezension

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Taschenbuch
"Bitte wiederholen"
EUR 24,06 EUR 0,78
4 neu ab EUR 24,06 13 gebraucht ab EUR 0,78

Hinweise und Aktionen

  • Große Hörbuch-Sommeraktion: Entdecken Sie unsere bunte Auswahl an reduzierten Hörbüchern für den Sommer. Hier klicken.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Produktinformation

  • Taschenbuch: 161 Seiten
  • Verlag: Pragmatic Bookshelf; Auflage: 0002 (30. September 2003)
  • Sprache: Englisch
  • ISBN-10: 0974514004
  • ISBN-13: 978-0974514000
  • Größe und/oder Gewicht: 19 x 1,6 x 22,9 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 1.094.134 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über die Autoren

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Synopsis

This book is a recipe-based approach to using the CVS Version Control system that will get you up and running quickly--and correctly. All projects need version control: it's a foundational piece of any project's infrastructure. Yet half of all project teams in the U.S. don't use any version control at all. Many others don't use it well, and end up experiencing time-consuming problems. Version Control, done well, is your "undo" button for the project: nothing is final, and mistakes are easily rolled back. With version control, you'll never again lose a good idea because someone overwrote your file edits. You can always find out easily who made what changes to the source code--and why. Version control is a project-wide time machine. Dial in a date and see exactly what the entire project looked like yesterday, last Tuesday, or even last year. This book describes a practical, easy-to-follow way of using CVS, the most commonly used version control system in the world (and it's available for free). Instead of presenting the grand Theory of Version Control and describing every possible option (whether you'd ever use it or not), this book focuses on the practical application of CVS.

It builds a set of examples of use that parallel the life of typical projects, showing you how to adopt and then enhance your pragmatic use of CVS. With this book, you can: Keep project all assets (not just source code) safe, and never run the risk of losing a great idea; Know how to undo bad decisions--no matter when they were made; Learn how to share code safely, and work in parallel for maximum efficiency; See how to avoid costly code freezes; Manage 3rd party code Now there's no excuse not to use professional-grade version control.

Über den Autor und weitere Mitwirkende

Dave Thomas and Andy Hunt have more than 50 years combined experience, developing software for clients around the world. For the last 10 years they've been working together as The Pragmatic Programmers, helping clients write software and improve their development processes. They are authors of the best-selling The Pragmatic Programmer, and have written several other books. They speak at conferences globally, and are editors of IEEE Software's "Construction" column.

Kundenrezensionen

5.0 von 5 Sternen
5 Sterne
1
4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

4 von 4 Kunden fanden die folgende Rezension hilfreich Von Gregor Theis am 24. Februar 2005
Format: Taschenbuch Verifizierter Kauf
"Pragmatic Version Control using CVS" ist ein Buch über Versionskontrolle für Software unter Verwendung von CVS. Es handelt sich um ein weiteres Buch aus dem "Pragmatic Bookshelf" der Autoren des "Pragmatic Programmers", was ich sehr empfehlen kann.
Ich habe vor diesem Buch ein Buch über CVS gelesen, was mir CVS vollständig erklärt hat (ich habe es nicht ganz verstanden). Thomas und Hunts Buch will dem Leser nicht die gesamte Funktionalität von CVS erklären, sondern nur den wichtigen Teil UND es beschreit wie und warum man CVS (pragmatisch) nutzen sollte. "PVS using CVS" hat mir nicht nur erklärt, wie man einen Code Branch anlegt sondern auch ein sinnvolles Vorgehen beschrieben, wann man dieses machen sollte und wie man anschließend mit diesem Branching umgeht (Zurückmergen).
Zusätzlich zu den Vorgehensinformationen bekommt man auch eine Einführung in die Installation und Anwendung von CVS geboten, die ich sehr gelungen finde. Ich habe jetzt auch verstanden, wie man Module und Fremdhersteller Code Funktionen in CVS einsetzt (und vor allem auch wann).
Die Kapitel sind kurz und knapp mit wichtigen Informationen, um schnell starten zu können. Endlich einmal ein Computer Buch, dass man in endlicher Zeit lesen kann und keinen unnützen Ballast enthält.
Zu "Pragmatic Version Control using CVS" gibt es eine deutsche Übersetzung unter dem Titel "Pragmatisch programmieren - Versionsverwaltung mit CVS", die ich nicht gelesen habe.
Lesen Sie weiter... ›
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 10 Rezensionen
33 von 33 Kunden fanden die folgende Rezension hilfreich
The idioms you need; not just doc you find elsewhere 17. März 2004
Von Bob Carpenter - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Hunt and Thomas, "The Pragmatic Programmers", provide a delightfully brief user's guide for the Concurrent Version System (CVS). They focus on idiomatic usage patterns, leading the way from installing CVS and creating a first project to branching for releases and developer sandboxes. They provide practical advice on when to branch, how to comment, what constitutes a project, and even what to check into CVS in the first place. I've been using CVS for years, and learned a lot here; especially about the various kinds of diff reporting and configuration options.
Almost everyone is confused by CVS first. Almost everyone who gets over the learning curve swears by it (or some variant). The main adoption hurdle is the unix-style documentation that provides telegraphic explanations of commands in insider jargon. Hunt and Thomas explain what it all means, and more importantly, how to use it, and why to use it. Complex relationships like merge conflicts are illustrated with clear diagrams and sensible easy-to-follow examples. Even though I see myself using this book quite a bit, I could've used it even more when I was getting started, before CVS became second nature.
9 von 9 Kunden fanden die folgende Rezension hilfreich
be the CVS Zen master 13. September 2004
Von Dirk Schreckmann - Veröffentlicht auf Amazon.com
Format: Taschenbuch
(The following is an excerpt of a review of "The Pragmatic Starter Kit" I posted at JavaRanch.)

Authors, David Thomas and Andrew Hunt, smashed a home run with their book, "Pragmatic Version Control Using CVS" - the first volume in the three part "The Pragmatic Starter Kit" series. Using easy to read explanations, examples and stories, this book clearly explains what version control is, how it works, why folks are using it, how CVS works, and what commands developers are using during the life of their projects. "Pragmatic Version Control Using CVS" provides the semantics and idioms behind the syntax found in the CVS Manual. Before reading this book, I was a timid CVS user, willing to do little more than check code out. Now, after reading the book, I check code out and in, branch, merge and resolve conflicts with confidence. I'd recommend this book to any developer using a version control system that wouldn't already describe themselves as Zen masters in the craft, and to any developer not already using a version control system.
6 von 6 Kunden fanden die folgende Rezension hilfreich
How to do it 2. April 2006
Von Noah Green - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
I've been grappling with the Concurrent Versioning System (CVS) for years. Moreover, I've been misusing it. Baffled and intimidated by its cryptic syntax and concepts, I've missed out on the power of branching and tagging, and the way these tools can be used to clearly demarcate project releases and versions. Using CVS as little more than a safer place to keep code than a local hard drive and an easier way to pass code around than FTP, I and my teams have failed to benefit from version control's true purpose. Checking code into the mainline only, we've found ourselves holding off on writing or checking in new code while a release is underway, and being forced to add new, untested code to a stable past release in order to fix a bug.

CVS's documentation has never helped matters. The free online manuals (aka "The Fish Book", "The Cederqvist", etc.) are classics and miss no detail documenting CVS's complex and option-laden commands, but say little about what exactly to do with the commands in order to run a successful software project. Other commercial CVS books essentially have been longer-form rewrites of the original manuals. And through it all, CVS's syntax has remained complex and intimidating.

Along comes Pragmatic Version Control Using CVS. With clarity, brevity, and humor, its authors show that version control can and must be the centerpiece of any development process, and they show how to make the humble, aging CVS work as that centerpiece. Taking the successful 80/20 approach, they cover only the features necessary to support the important things in software project execution: maintaining separate versions, marking releases and bug fixes, merging fixes to an old release into the latest version, and even bonus topics like managing third-party code. They take an Occam's Razor to CVS's syntax, leaving you with a small, essential slice that's easy to remember and use. Alongside this syntax, the authors suggest idioms, naming conventions, and techniques. What you end up with is the bare bones of how to run a software project. You start to feel like you're not even using CVS - that you could be using any version control system. The syntax becomes secondary and the process takes center stage.

Here is a summary of their approach: (1) Develop on the mainline; (2) Branch only from the mainline, and only when you're ready to put out a release (or experiment with some great departure from the current codebase); (3) Tag the branch when the release is done; (4) Return to the branch to fix a post-release bug; (5) Tag the branch before and after the bug fix; (6) Merge the bug fix back into the mainline; (7) Get back to work on the mainline; (8) Go home at a reasonable hour. In between all these steps, part of your team can work on the latest version while others launch or patch a release. Old work will not impede new work; new work will not pollute old work. The authors put the "concurrent" back into "CVS."

That's the undergirding of a solid development process. All you need is a tiny subset of CVS's baffling syntax to do it. The book describes the subset.

Please understand that this is not a definitive CVS reference. The authors don't document anything unrelated to the process. Armed with the common sense gained from the Pragmatic book, you can go to the original docs and find what you want.

I read this book over a year ago, and have waited until now to review it. In that time, I've successfully implemented most of its practices in the team that I lead. We can pull down the code tree of any of our past releases in an instant, fix a bug, and redeploy, all without affecting current development efforts - or having those development efforts affect the old release. There's never a question as to which version of the code we're working on. We're safer, smarter, and faster. All it took was a 175 page book, a free version control system, and a bit of open-mindedness. If you're not already doing what this book shows you how to do, start now.
4 von 4 Kunden fanden die folgende Rezension hilfreich
Chatty but Misses Information 30. Januar 2006
Von Ray Salemi - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I bought this book to come up to speed on CVS for a new project and I had a mixed experience with it.

I like the author's simple examples. For example, using a short text list of colors as sample files instead of source code. These made it easy to focus on the author's intent without getting confused by the example.

However, I had a problem in that the book never really compared CVS to other tools. I have always used source control tools that locked other users out of a file when you edited it: RCS, Clearcase, etc. So I found myself flipping through the book trying to figure out how to do a "get" command. I wish there had been a section describing the CVS philosophy of letting everyone edit and only fixing the merges.

I found the author's chatty style to be distracting. But, on the other hand, I am now successfully using CVS from using this book. So 3 stars.
3 von 3 Kunden fanden die folgende Rezension hilfreich
An awesome jump-start guide 10. März 2005
Von Kevin J. Schmidt - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I read this book cover-to-cover in two days. Don't mistake this as the book being lightweight. This book captures the essentials for using CVS in small, medium, and large projects. I've used CVS since 1997 in various aspects. In my experience, the authors present material that I've learned over the last eight years in an easy-to-read and easy-to-digest format. They touch on the basics, but the basics are really all many organizations need. I have been involved with projects where complex branching and tagging schemes were devised, which makes it hard to focus on actually writing code; you spend too much time dealing with bookkeeping, etc. The authors provide a no-nonsense way of using branches and tags that makes sense and is easy to grasp. This book is no replacement for some of the other CVS books out there that tend to focus on all aspects of CVS (administartion, coding, etc.) but if all you want is a great introduction to 97% of what you need to know as a developer, then get this book!
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.