Loggen Sie sich ein, um 1-Click® einzuschalten.
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an.
Jetzt eintauschen
und EUR 7,95 Gutschein erhalten
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Keine Abbildung vorhanden

Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Test Driven Development for Embedded C (Pragmatic Programmers) [Englisch] [Taschenbuch]

James W. Grenning
5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
Statt: EUR 23,95
Jetzt: EUR 22,95 kostenlose Lieferung. Siehe Details.
Sie sparen: EUR 1,00 (4%)
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 7 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Freitag, 29. August: Wählen Sie an der Kasse Morning-Express. Siehe Details.


3. Mai 2011 Pragmatic Programmers
Did you write C code last week? Does your code work? Is your design clean? If you answered yes to the first question but got queasy over the second two, you need to know about Test Driven Development. TDD helps you write code that works the first time, and then helps you keep it running as the code evolves to meet new needs. In Test Driven Development for Embedded C, author James W. Grenning shows embedded software developers how to bring the benefits of TDD to embedded C. In the book, you'll see how to apply TDD to C and the world of embedded software development. Learn how to break key dependencies, allowing code to be tested thoroughly. Explore how to test-drive your product's core logic, exploiting the power of your development environment to deliver better software. In fact, as the book shows, you can test-drive a device driver before you even have the device soldered into a circuit board. Avoid the natural delays when testing on the target by using the tailored TDD Microcycle, employing off-target tests and dual-targeted code. Learn how to make code testable and more flexible, better able to handle the inevitable changes demanded by the market. The tests drive development and then serve as an executable specification, keeping track of the critical details and assumptions baked into the code. In Test Driven Development for Embedded C, you'll find that TDD is a different way to program-unit tests are written in a tight feedback loop with the production code, producing testable code and greatly reducing wasteful debugging. TDD also influences design. When tests are considered part of design, you create modular and loosely coupled code, the hallmarks of a good design. With Test Driven Development for Embedded C, C developers-even embedded C developers-can finally write cleaner, testable code with TDD.

Wird oft zusammen gekauft

Test Driven Development for Embedded C (Pragmatic Programmers) + Making Embedded Systems: Design Patterns for Great Software + Software-Test für Embedded Systems: Ein Praxishandbuch für Entwickler, Tester und technische Projektleiter
Preis für alle drei: EUR 90,80

Die ausgewählten Artikel zusammen kaufen


  • Taschenbuch: 352 Seiten
  • Verlag: O'Reilly Vlg. Gmbh & Co.; Auflage: 1 (3. Mai 2011)
  • Sprache: Englisch
  • ISBN-10: 193435662X
  • ISBN-13: 978-1934356623
  • Größe und/oder Gewicht: 22,8 x 19,1 x 2 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 58.820 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

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



""This book is targeting the embedded-programmer-on-the-street and hits its target. It is neither spoon-fed baby talk nor useless theory-spin. In clear and simple prose, James shows working geeks each of the TDD concepts and their C implementations. Any C programmer can benefit from working through this book."" --Michael "GeePaw" Hill, Senior TDD coach, Anarchy Creek Software ""I have been preaching and teaching TDD in C for years, and finally there is a book I can recommend to fellow C programmers who want to learn more about modern programming techniques."" --Olve Maudal, C programmer, Cisco Systems""James is a true pioneer in applying Agile development techniques to embedded product development...this book was worth waiting for. This is a good and useful book that every embedded developer should read.""--Bas Vodde, Author of "Scaling Lean and Agile Development" and "Practices for Scaling Lean and Agile Development," Odd-e, Singapore

Über den Autor und weitere Mitwirkende

James Grenning trains, coaches, and consults worldwide. His considerable experience brings depth in both technical and business aspects of software development. James is leading the way to introduce Agile development practices to the embedded world. He invented Planning Poker and is one of the original authors of the Manifesto for Agile Software Development, February 2001.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?

Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen


4 Sterne
3 Sterne
2 Sterne
1 Sterne
5.0 von 5 Sternen
5.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
5 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Das was C Programmierern bisher gefehlt hat 25. November 2012
Von Daniel S.
Format:Taschenbuch|Verifizierter Kauf
Ich bin Embedded SW Entwickler, besitze das Buch seit einiger Zeit und setze es in der Praxis als Freiberufler bei Projekten regelmäßig ein. Wenn man nur ein Buch benötigt, welches in kurzer Zeit die wichtigsten Themen in Zusammenhang mit TDD für C beleuchtet, dann ist es dieses. Es ist prägnant, führt in das Thema ausreichend ein und verweist zu passenden Frameworks und verwandter Fachliteratur. Ich selbst benutze von den vorgestellten Test-Frameworks CppUTest und kann dieses - wie der Autor auch - nur wärmstens empfehlen.
Als passende Ergänzung zu diesem Buch ist das umfangreiche Buch "Working Effectively with Legacy Code" anzuraten, welches bei Refakturierungsaufgaben noch wesentlich detaillierter vorgeht.
Dieses Buch sollte bei jedem C/C++ Entwickler auf dem Schreibtisch stehen. 5 Sterne.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.6 von 5 Sternen  16 Rezensionen
12 von 12 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Just what I was looking for 2. Juni 2011
Von Jan-Harald Fredriksen - Veröffentlicht auf Amazon.com
As the other reviews have stated, this is a very good book. I had been looking for a book like this for a while, so I first picked this up in a beta version from the Pragmatic Programmers website.

The two first section give a wonderful introduction to TDD in C. By the end of the second section, Grenning has covered the reasons for doing TDD, looked at available tools, and introduced various methods (spies, test doubles, mocks) for breaking module dependencies during testing. Lots of code examples are included throughout. These two sections were by far the most useful to me. Having been a programmer for a number of years without doing TDD, I needed some convincing, so the "Yeah, but..." chapter was spot on.

The third section (Design and Continuous Improvement) feels a little bit more unfocused. It covers three rather large topics (SOLID design, refactoring, and working with legacy code) that all deserve (and have) whole books dedicated to them. It may be intended as further examples of how to apply TDD, and it does do a fine job of that.

In short, I think this book serves as a very good introduction to the topic. That does not mean, however, that it answered all my questions about TDD. Most of these question revolve around how these techniques scale up to larger projects and teams.
Two examples:
* In Chapter 10 it is stated that "Mocks enforce a strict ordering of interactions, which can lead to fragile tests ...". I would have loved to read some thoughts on when this is likely to occur, possible solutions, etc.
* The LED driver example is a good example, but it isn't immediately obvious how this approach would scale to larger hardware blocks (say, a co-processor).

Also, performance concerns are mentioned a few times, but may have had deserved a little more space. For example, in Chapter 3 it is stated that abstract data types are hidden (only forward declared in the header) from the caller. In its naïve form, this does not allow for inlined function calls, which can still be a performance problem on some platforms. A discussion on how to deal with issues like this would have been useful.
13 von 15 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen The word is out. TDD works for C! 30. Mai 2011
Von Bas Vodde - Veröffentlicht auf Amazon.com
Test-Driven Development for C does exactly what the title promises you. It describes how to do Test-Driven Development in the C programming language. People have argued that Agile development is for modern projects, but not embedded ones. Test-Driven Development can work in Object-Oriented languages but not in programming languages like C. James proves this wrong by showing how you can test-drive you code in C.

The book consists of 4 different parts of which the last part are the appendices, which I'll skip in this review. The first part covers the basics of TDD, the second part discusses how to test a module that has dependencies with other modules. The third part discusses the design aspects of TDD.

The first chapter introduces the concept of test-driven development after which the author continues introducing the two unit test frameworks used in the book: Unity and CppUTest. In the third chapter, the LED example is introduced and used to clarify TDD. The fifth chapter dives in the embedded space and discusses dual targeting and other embedded C techniques. The first part ends with an summary of objections that people typically have against TDD and an counter argument for each other them.

The second part continues with a more complicated example (light automation system). This system has multiple modules and thus each of the modules need to be separated to be able to test it. Chapter 8 discusses link-time substitution and chapter 9 then dives into how to do this at run-time. Chapter 10 introduces Mock objects by first writing one by hand, and then introducing CppUTest mocking and CMock.

The last part dives into design. In the end, TDD is a design technique, so a TDD book couldn't do without diving deeper into design. Chapter 11 introduces the SOLID OO principles and shows that OO principles are valid principles... even when your programming language is not an OO language, such as C. Chapter 12 introduces refactoring in C and the different code smells that are common triggers to refactor. Chapter 13 covers how to deal with legacy code and, the last chapter, covers patterns for writing good (and bad) tests.

James Grenning's TDD is C is a very much needed book. Embedded software statistics in the world show that the amount of embedded software in the world is growing fast. Most of this embedded software is still done in C. The embedded software community hasn't learned the new development techniques that have changed application development the last 10 years, such as TDD. James finally introduces these important changes in development style to the embedded community. His book is easy to read, funny, and useful. Most of all, it was just needed! I have been doubting between 4 and 5 stars (4 as it does what it says, 5 because it is the first book of its kind) and decided to stick with 5 stars. Well done, James :)
52 von 68 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen There is nothing on embedded programming 5. Juli 2011
Von Maduranga - Veröffentlicht auf Amazon.com
For those who don't want to go through the entire review, here's the summary: Despite including "Embedded C" in the title, this book does not include anything at all particular to embedded programming. This is an introduction to TDD book, and in my opinion not such a good one either.

Here's the breakdown:

I'm a firmware developer so I picked this book up because, (1) I wanted to learn TDD and, (2) I wanted to learn how to apply it to embedded programming. So I thought I can kill two birds with one stone buying this book. Sadly this book does a very poor job at both. In my opinion, anybody picking up a book on TDD is not a beginner in programming. This is a place the book gets things wrong first. It is unnecessarily overly verbose at times, explaining simple things duplicating before and after code snippets. On the other hand, some important points are not explaining enough. For example, the only two points I found useful in this book was link-time substitution and function pointer use. These are not new to a programmer, but I felt are very useful when applying TDD, especially when working with existing legacy code (which most of us will have to work on one time). But the book doesn't explain them in detail (as it does other very trivial topics).

And for the biggest dissapointement, this book has nothing special for embedded programming. The closest the author gets to an embedded system are the two exaplme projects he presents in the book, the LedDriver and the LightScheduler. These two are very simple to qualify as an embedded system, because usually an embedded system is much more complex than turning on an LED at the given time.

An embedded system program differs from a normal program in many ways. For example, an embedded system has to deal with interrupts, exceptions, DMA, memory accesses, wait states, serial/link port communications, synchronization, processing power, etc. There is absolutely nothing about this in this book. The only place you find anything about embedded is when author tells some "stories" about embedded projects and in appendix where a very short explanation to running on Linux and uC OS is presented.

Overall the book is disappointing because it doesn't deliver to its title embedded C. And then, even as a book on introduction to TDD, I cannot say I'm very impressed. It is very verbose when it clearly doesn't need to be, and not verbose enough when it should be.

I hope the author revises the book and put more embedded programming related contents because at this state the books' contents doesn't do justice to the title.
7 von 8 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Changes how I develop 28. April 2011
Von Matt Wilbur - Veröffentlicht auf Amazon.com
This book is fantastic. If you do development in C for embedded work (or C++ for that matter), buy it. Go on. Click the "Add to cart" button right now. I'll wait. Done? Good.

As a backgrounder, I have been doing engineering work for almost 10 years now, but have only been doing embedded software for a little over 2.5. In that time, I have been trying to find a way to develop that made it easier to develop from a blank slate. I had seen designs I had liked, but I just didn't know how to create them myself. "Test-Driven Development for Embedded C" is, without a doubt, what will help me get there.

TDD was appealing to me, but I despaired because I was doing embedded work. I had drivers to work on, dammit. I couldn't use Java, or Smalltalk, or Ruby. I think it was a Google search that landed me on the Pragmatic Programmer web page for Test-Driven Development for Embedded C. "Is this for real?", I thought. Yes it was. Unfortunately, it wasn't in print yet. But, there was the Beta Book. I more than willingly shelled out and worked from that.

I admit, it collected dust for a while as I worked on this thing or that, where I was essentially working with other people's code and I didn't think I could make use of the book (I know I'm wrong about that now, but I digress). My current project, though, was going to be my own and fairly complex. I needed something to reduce my stress. So, I went back to James' book. I ate it up steadily until I was about 70% through, and I decided to take the leap. I've been using TDD (with diligence, on the average) for about four weeks now and I can't imagine coding any other way.

Admittedly, I do some things a little differently than the book does, but this book is my cornerstone. I worked through the examples myself (peeking at the book's downloadable code from time-to-time), up to and including the Mock Objects chapter (Driver development off-hardware? Insane!). After that, I could mostly get by with reading.

James does a great job at taking the reader from a standing start through some fairly realistic examples. All the code is on the book's website, so you can always grab it, but do yourself a favour and work through it from scratch. Yes, getting going will be bumpy, but there's no teacher like experience. In addition, James himself is available on the book's forum on the PragProg website, as well as on the Agile Embedded Yahoo! group where he will answer questions. Others will too. People get fanatical about this stuff, and I now understand why.

I have been developing one module using TDD for a couple of weeks now, and I've never been more confident or proud of my C code before.
4 von 4 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Not just informative, but transformative. 28. Juli 2012
Von Eric Ross - Veröffentlicht auf Amazon.com
I read many books on software test and there are two things that make this book unique and worth having on your bookshelf. First, it focuses on the unique needs of embedded firmware. Secondly, it does it using an approach that builds one capability upon another capability in working with this especially difficult type of testing.

I work with about 300 other firmware engineers on a code base consisting of over 1 million lines of code and I, frankly, was a bit skeptical about being able to use TDD in such an environment with the huge base of legacy code that we have to manage. As the lead for firmware quality, I had to dramatically shift the mindset on how test was done on our code base from a traditional toss it at QA until it doesn't get tossed back to an R&D owned and executed test environment. Many of my initial presentations were based on Chapter 6 "Yeah, but..." which is one of the best synopsis of objections I have heard over the years to doing this kind of testing on embedded systems. After demonstrating the technique to some open minds, I handed over the book and they ran with it. We now have some very enthusiastic champions for transforming our development processes and Test-Driven Development for Embedded C is a key contributor.

It was clear that James W. Grenning attempted to keep the depth light enough that one could read through and start using the techniques very quickly. For your test leads who hunger for more I recommend supplementing this with a more in-depth book: Working Effectively with Legacy Code
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Erster Beitrag:
Eingabe des Log-ins

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen

Ähnliche Artikel finden

Ihr Kommentar