undrgrnd Cliquez ici Bests nav-sa-clothing-shoes nav-sa-clothing-shoes Cloud Drive Photos cliquez_ici nav_HPTV Cliquez ici Acheter Fire Acheter Kindle Paperwhite cliquez_ici Jeux Vidéo Montres soldes Bijoux Soldes
Commencez à lire Modern C++ Programming with Test-Driven Development sur votre Kindle dans moins d'une minute. Vous n'avez pas encore de Kindle ? Achetez-le ici Ou commencez à lire dès maintenant avec l'une de nos applications de lecture Kindle gratuites.

Envoyer sur votre Kindle ou un autre appareil


Essai gratuit

Découvrez gratuitement un extrait de ce titre

Envoyer sur votre Kindle ou un autre appareil

Désolé, cet article n'est pas disponible en
Image non disponible pour la
couleur :
Image non disponible

Modern C++ Programming with Test-Driven Development: Code Better, Sleep Better [Format Kindle]

Jeff Langr

Prix conseillé : EUR 33,08 De quoi s'agit-il ?
Prix livre imprimé : EUR 37,65
Prix Kindle : EUR 23,16 TTC & envoi gratuit via réseau sans fil par Amazon Whispernet
Économisez : EUR 14,49 (38%)

App de lecture Kindle gratuite Tout le monde peut lire les livres Kindle, même sans un appareil Kindle, grâce à l'appli Kindle GRATUITE pour les smartphones, les tablettes et les ordinateurs.

Pour obtenir l'appli gratuite, saisissez votre adresse e-mail ou numéro de téléphone mobile.


Prix Amazon Neuf à partir de Occasion à partir de
Format Kindle EUR 23,16  
Broché EUR 38,01  
-40%, -50%, -60%, -70%... Découvrez les Soldes Amazon jusqu'au 16 février 2016 inclus. Profitez-en !

Les clients ayant acheté cet article ont également acheté

Cette fonction d'achat continuera à charger les articles. Pour naviguer hors de ce carrousel, veuillez utiliser votre touche de raccourci d'en-tête pour naviguer vers l'en-tête précédente ou suivante.

Descriptions du produit

Présentation de l'éditeur

If you program in C++ you've been neglected. Test-driven development (TDD) is a modern software development practice that can dramatically reduce the number of defects in systems, produce more maintainable code, and give you the confidence to change your software to meet changing needs. But C++ programmers have been ignored by those promoting TDD--until now. In this book, Jeff Langr gives you hands-on lessons in the challenges and rewards of doing TDD in C++.

Modern C++ Programming With Test-Driven Development, the only comprehensive treatment on TDD in C++ provides you with everything you need to know about TDD, and the challenges and benefits of implementing it in your C++ systems. Its many detailed code examples take you step-by-step from TDD basics to advanced concepts. As a veteran C++ programmer, you're already writing high-quality code, and you work hard to maintain code quality. It doesn't have to be that hard.

In this book, you'll learn:

how to use TDD to improve legacy C++ systems

how to identify and deal with troublesome system dependencies

how to do dependency injection, which is particularly tricky in C++

how to use testing tools for C++ that aid TDD

new C++11 features that facilitate TDD

As you grow in TDD mastery, you'll discover how to keep a massive C++ system from becoming a design mess over time, as well as particular C++ trouble spots to avoid. You'll find out how to prevent your tests from being a maintenance burden and how to think in TDD without giving up your hard-won C++ skills. Finally, you'll see how to grow and sustain TDD in your team.

Whether you're a complete unit-testing novice or an experienced tester, this book will lead you to mastery of test-driven development in C++.

What You Need

A C++ compiler running under Windows or Linux, preferably one that supports C++11. Examples presented in the book were built under gcc 4.7.2.

Google Mock 1.6 (downloadable for free; it contains Google Test as well) or an alternate C++ unit testing tool. Most examples in the book are written for Google Mock, but it isn't difficult to translate them to your tool of choice.

A good programmer's editor or IDE.

cmake, preferably. Of course, you can use your own preferred make too. CMakeLists.txt files are provided for each project. Examples provided were built using cmake version 2.8.9.

Various freely-available third-party libraries are used as the basis for examples in the book. These include:- cURL- JsonCpp- Boost (filesystem, date_time/gregorian, algorithm, assign)Several examples use the boost headers/libraries. Only one example uses cURL and JsonCpp.

Détails sur le produit

  • Format : Format Kindle
  • Taille du fichier : 912 KB
  • Nombre de pages de l'édition imprimée : 361 pages
  • Pagination - ISBN de l'édition imprimée de référence : 1502445115
  • Utilisation simultanée de l'appareil : Illimité
  • Editeur : Pragmatic Bookshelf; Édition : 1 (10 octobre 2013)
  • Vendu par : Amazon Media EU S.à r.l.
  • Langue : Anglais
  • ASIN: B00HUEG8M8
  • Synthèse vocale : Activée
  • X-Ray :
  • Word Wise: Non activé
  • Composition améliorée: Non activé
  • Classement des meilleures ventes d'Amazon: n°84.022 dans la Boutique Kindle (Voir le Top 100 dans la Boutique Kindle)

En savoir plus sur l'auteur

Découvrez des livres, informez-vous sur les écrivains, lisez des blogs d'auteurs et bien plus encore.

Commentaires en ligne

Il n'y a pas encore de commentaires clients sur Amazon.fr
5 étoiles
4 étoiles
3 étoiles
2 étoiles
1 étoiles
Commentaires client les plus utiles sur Amazon.com (beta)
Amazon.com: 3.8 étoiles sur 5  10 commentaires
13 internautes sur 14 ont trouvé ce commentaire utile 
3.0 étoiles sur 5 Not what I expected - a little disappointed 23 novembre 2013
Par alejandro claro - Publié sur Amazon.com
Format:Broché|Achat vérifié
Do not misunderstand me . It is not a bad book, but should be read with critical judgment. I had more expectations of the content of the book and answers to complicated issues with TDD in C++ that were not answered. The solutions were obvious and that is precisely the problems for I want answers and learn about better alternatives.

Uncle Bob as indicated in the foreword, the title is not the best. Nor do I agree with the title suggests Robert Martin. The title that best describes it is "Introduction to TDD by examples in C++". You will not find anything they have not seen in tutorials and in common internet discussions. The book is not very long and most of its contents are the examples with the refactors step by step. Langr makes a good attempt to explain what it does as it develops the examples, though often repetitive and a bit inconsistent at conventions.

Some of his thoughts on occasion contradict, but understandable since he tries to be pragmatic in his decisions through the examples, which should be better explained. An inexperienced reader might take quite literally many of the tips that in my opinion are generally not the best options. This kind of advice and rules, out of context cause many developers to perform stupid things.

All you have modern C++ is the use of some things in the new C++11 standard: use of 'auto', range-based for loop, some lambdas, not consistently use uniform initialization. Disuse many features and best practices in C++11.

The idea of ​​the review is not to touch all points and tips that I have an opinion. I will probably make a more extensive review on a blog. For now, I recommend to any reader to read it critically and do not accept the ideas without seeking alternatives, understand the context in which it is developing and consult with more experienced colleagues.
5 internautes sur 6 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Well-written yet time consuming 21 janvier 2014
Par K. Paulus - Publié sur Amazon.com
Format:Broché|Achat vérifié
I wish my organization would have had access to this book YEARS ago – it would have saved us a lot of time, heartache, and false starts when it came to unit testing in C++. The author states at the beginning that the reader will get the most out of the book by actually working through the exercises instead of just reading, and I wholeheartedly agree. It is through practice that we begin to change our habits, and I had many “a-ha” moments while doing the exercises that I surely would not have experienced via skimming. Versioned source code for each chapter can be found on the author's github site.

The main reason why I gave this 4 stars instead of 5 is that the author creates unnecessary roadblocks to getting the exercises up and running. Yes, there will always be some setup investment, but many exercises needlessly depend on a variety of external libraries. I would be so excited to dive into a new chapter, only to find out that I first needed to download and build yet another library that I never have and probably never will use outside the context of this book. Most of these are easily avoidable; for example, the production code for Chapter 5 uses cURL, which ends up getting mocked out in test anyway. Chapter 6 relies on boost::gregorian (which is separate from the main boost library) when it could instead use time_t and save the reader time (no pun intended).

Adding insult to injury, Chapter 8 randomly switches unit test frameworks, from GTest to CppUTest. Unfortunately that was the chapter I had most been looking forward to exploring, but when I got to that point I had already far surpassed what I'd time-boxed for this book and could not afford the overhead of getting another framework up and running. The author could have also provided more support for commonly-used IDEs. These symptoms all bring me to the conclusion that the author did not recruit a diverse enough base of beta testers to provide brutally honest feedback before the book went to print. I can only hope that he releases a more user-friendly revision soon.

I would also like to echo another reviewer's dismay about the lack of community support. Why set up a Google Group instead of using a forum with more regular activity like stackoverflow?

Despite the aforementioned shortcomings, this book is an absolute must for anyone trying to get started with unit testing in C++. It is well-written, well-organized, and keeps the reader's attention, unlike other programming books which provide a sure cure for insomnia. Take the time to work through the exercises - you'll be glad you did.
2 internautes sur 2 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 A great book on a great technique. C++ is just the sideshow. 4 décembre 2014
Par Sean A. Levin - Publié sur Amazon.com
I really love this book. Good sense of humor and a great exploration of TDD style programming (which after 15 years of not doing I've become a 100% convert to). Its definitely meaty with lots of code, so if you are looking for a quick read, you'll miss a lot of how things work. Its also a nice demonstration of the way C++ can be written well (difficult as that may be). I think he's done a great job.

If you haven't read Test Driven Development: By Example by Kent Beck, that's also required reading, especially if you haven't been exposed to TDD.

I think a lot of people (myself included) who've been programming for a long time in the classic get-er-done style, feel a visceral negative reaction to this approach, since it feels extreme. Its kind of a "who do they think they are telling me I'm doing it wrong!?" feeling. The humility with which authors like Beck, Langr, Fowler, Martin, and Kerievsky present techniques that have made them expert practitioners is almost surprising. One would expect them to be smug or superior. Instead they all write as if they are the lucky ones who've been exposed to things greater than themselves and really just want to share a great way of developing software. I'm glad to have discovered all of them.
4 internautes sur 5 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Test-Driven Development in C++. Finally! 2 janvier 2014
Par Bas Vodde - Publié sur Amazon.com
I'm very excited about "Modern C++ Programming with Test-Driven Development" by Jeff Langr. I've been test-driving (TDD) code in C++ for a very long time and a common reaction is: Can you do that? Yes, you can! However, before Jeff's book there was actually very little available about test-driven development in C++... and as far as I know, Jeff's book is the first (There is a Test-Driven Development in C though, by James Grenning). And Jeff's book is a pretty good introduction to test-driven development in C++.

The book consists of 11 chapters and is a bit over 300 pages. There is quite a lot of code in the book (as it should be!) and it doesn't always read fast. Yet, it was a pretty easy read. The book isn't divided in any parts, but if it would be, I'd consider there three parts int he book, 1) Introduction to TDD, 2) Intermediate topics, and 3) Special topics.

The first three chapters serve as an introduction to Test-Driven Development. Actually, the first chapter is to set-up your environment. The second chapter test-drives a simple class (SoundEx) and shows each step and thought in a lot of detail. The chapter is about 40 pages and does a decent job showing the basics of TDD. The third chapter covers the theory behind TDD, the steps, rules and some basic techniques.

With the basics of TDD done, the next chapter looks at how tests are described, how to organize your tests, what fixtures are and some additional techniques related to creating tests. Fairly early on when test-driving code, you'll get stuck with dependencies and chapter five introduces mock objects (test doubles) that help you deal with these dependencies. Chapter six explores the design aspect of TDD. It is essential to understand TDD not as a testing technique but to help you with designing your software. Chapter seven talks about how to keep your tests maintainable and of a high quality. Making sloppy tests and having to maintain them is one of the most common pitfalls I've seen when adopting test-driven development.

The last part consists of three chapters. Chapter eight is about working with legacy code. An essential chapter as most C++ projects do not start from scratch and people adopting test-driven development will definitively need to deal with existing legacy code. Chapter 9 discusses test-driven development and multi-threading. I'm not sure this topic would need a whole chapter by itself. Chapter ten is a left-over chapter with ideas related to TDD.

The last chapter "Growing and Sustaining TDD" is a sort-of adoption chapter and gives some tips on how to start, how to get better, and how to work as a team.

I'm very happy Jeff published this first TDD in C++ book. It is a good book. It isn't a perfect book. Personally I felt that the usage of C++11 could have been skipped as still not all (much?) developers are experienced in that. In addition, it still gives some trouble with compilers on different platforms. Also at times the examples felt a bit too slow. I've been going in between 4 and 5 stars a couple of times but like to give it a 4 star review. Jeff's "Modern C++ Programming" is the first and from my perspective is a book that was very much needed. Definitively recommended for learning TDD in C++!
2 internautes sur 3 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 This isn't your father's C++ 14 novembre 2013
Par Scott Fredericksen - Publié sur Amazon.com
Jeff's book is exactly what I needed at work. As a C++ shop, we felt left behind in all the TDD movements. Sure there were books out there on xUnit that we could read and translated into C++, but with Jeff's book, we didn't have to. He's got a lot of great experience and wisdom to share on the various C++ unit testing frameworks and he tries to keep it pretty platform agnostic. I'm definitely glad I added this to my shelf.
Ces commentaires ont-ils été utiles ?   Dites-le-nous

Discussions entre clients

Le forum concernant ce produit
Discussion Réponses Message le plus récent
Pas de discussions pour l'instant

Posez des questions, partagez votre opinion, gagnez en compréhension
Démarrer une nouvelle discussion
Première publication:
Aller s'identifier

Rechercher parmi les discussions des clients
Rechercher dans toutes les discussions Amazon

Rechercher des articles similaires par rubrique