Training Feedback -- 709 entries

Course Rating Most useful Concepts
v
Exercises
Presentation v Discussion Course improvements Exercise rating Exercise improvements Instructor comments Better prepared Start tomorrow Challenges to applying
TDD for Embedded C++ Very Good I knew nothing about TDD before this training. Post this training, I had some knowledge about TDD concepts. Good balance Good balance Very Good Could have used more time on the excercises.. A little Show
TDD for Embedded C++ Excellent 1) The reason behind doing TDD in the first place; it helps you to write bug free software so that with a little extra time up front you can save unlimited time on the back end since you no longer have to track down and fix bugs. They are fixed as soon as they are added. 2) The concept that we are not testing code operation but code paths, thus we can ignore timing constraints, external interfaces, etc. These can all be faked or mocked so that we can determine how the code actually works. Those other operations can be done as integration tests. Good balance Good balance Our company has projects in both C and C++ thus we had to split the legacy portion into how to work with C and how to work with C++. This would be better to focus on one or the other, perhaps split the legacy into two separate classes, but this is not James' fault and I believe that he handled it the best that he could. Very Good I thought the exercises were good at introducing the concept, showing how to implement it and showing the benefits. The projects chosen were meaningful and easy to understand and somewhat similar to objects found in our own code base, thus they were very useful. I honestly can't think of how they could be improved. James was very knowledgeable and able to find a way to work with problems we encountered while trying to develop tests for our legacy code base. He was patient and allowed us to discover our own solutions and only suggesting why our solution may not be the best. As I stated at the end of the class, James did not teach me anything I couldn't have learned on my own by reading books or looking on the internet but he did save me 3 to 6 months of fumbling around before I discovered the correct way to perform TDD. A very useful class. Much better I already have; I have continued with the legacy code example to create meaningful unit test for a section of our code that will be ported to our next gen platform while also needing some work. The biggest challenge will be taking the time to develop a useful suite of automated unit tests for our existing code bases. It probably doesn't make sense to do this for everything but at least start with those components that will either be changed in the future or will be ported to the next gen platform. Show
TDD for Embedded C++ Excellent That there is hope for better software. Good balance Good balance Very Good James was pleasant, knowledgeable and effective. He swam upstream against a almost hostile crowd but did manage to get his message seeded in the minds of many. Much better I think that I could apply the TDD process now. I know I am going to try. Lack of commitment from management and fellow engineers. Show
TDD for Embedded C++ Very Good Found the exploration of doubles (e.g., exploding fakes,mocks) to be of great interest and utility. Good balance Good balance There was some confusion when we got to the legacy code section regarding installation of tools. It would be nice if the various tools and examples were fully updated to represent the latest versions of the tools. Excellent Not sure they can be improved. They all seemed comprehensive and the cyber-dojo environment was quite easy to learn and use. I really liked the hands-on interaction that James encouraged and supported. Most of the time it did not feel like a normal instructor vs. class dynamic but, rather, as if we were all (including James) there for the same experience and working as nothing more than engineers exploring new tools and techniques. Bring it on! For the most part; TDD can start tomorrow but integration of the results into the integration framework will take a bit more time as all the projects have different environments. Acceptance from the engineering staff although I feel comfortable that most attendees are on board. Time will tell if schedule pressures become such that people revert to what they have known for years as opposed to continuing down the proper path with what they now know. Success with TDD will have to be embraced, and continue to be embraced, at all levels of the company for this to work. Show
TDD for Embedded C++ Good 2 things, the write a test, make the test fail, implement just enough code to make the test pass process. The second most useful thing is how to use the test environment and tools. Not enough exercises Good balance The first day was too much evangelizing. The second day was very valuable in using doing the exercises. The workshop was good in seeing how to apply tests to the existing code base. Very Good The exercises with the course were very good. During the workshop we got a bit lost a few times. Overall good. He presented the concepts well. In dealing with questions, he was sometimes dismissive of some questions or concerns that people raised. Much better Yes. We have tools available and some knowledge on how to use it. Lots of legacy code that will need to be refactored to make it effective for unit tests. Sometimes hard to turn the titanic once it has left the port. Show
TDD for Embedded C Very Good The methodology of TDD in practice as opposed to how it works in theory. Have tried to apply TDD by myself, without much success. Getting all the steps spelled out helped! Good balance Good balance Use an editor with syntax highlighting for exercises. :-/ Very Good Bring it on! Yep! Why? Because it changed the way I was thinking about how to write software - defining behaviour before implementation is a refreshing change of pace! Quite a lot of legacy code with large amount of coupling making TDD a bit harder to do. Show
TDD for Embedded C Excellent To write the minimal code to pass to pass the test Good balance Good balance Two days was a bit short to go through all the content. We were not able to complete all the exercises. Very Good Wish we had more time to do some of the exercises. But they gave a good introduction to how to efficiently use TDD. Bring it on! We already use TDD :) Show
TDD for Embedded C Very Good Structured approach to refactoring Good balance Good balance More embedded-related topics and look at legacy/embedded testing and TDD Excellent Much better Oh, I will! Code/build complexity Show
TDD for Embedded C Very Good I think the most useful was finding how useful TDD could be. Good balance Good balance Very Good Much better To truly get started with TDD we need to create an easy to use environment, if the test button is several jumps away it will not be used. I think convincing management that writing tests rather than features makes things better. Show
TDD for Embedded C Excellent Process of TDD, remind myself why we need tests. Good balance Good balance If there is more time perhaps include legacy code into workshops Very Good Maybe add some code which is not a straight forward class / unit. For embedded programmers it might be interesting to deal with even more hardware specific C. But for starting out TDD they are very good. James offers a very good insight into the TDD and his practical experience definitely helps him to expect and explain what problems may arise. Much better I think i can because we are starting with the new project. Initial environment setup and consistently applying these concepts. Show
TDD for Embedded C Very Good I think it was the whole concept of using such workflow for the development. Previously I was aware of some details about TDD, but while trying the ways if TDD now, everything was new. Good balance Good balance There were some issues with the dojo-box in web used for programming. The commits went sometimes out of sync after TEST button click -> no diff was added to the actual code (while still being visible in the diff view). Very Good Much better Yes, because we use similar unit-test framework to CppUTEST. We definitely do not follow the TDD development concept I learned during the training days now, but all the tools exists for that and i would not have any problems to continue this in my office. I still might need some tries to get more used to it - using the tests and TDD (as we learned during the practice) with such small steps was a challenge. But then again trying different things is essential. Probably just the time. As mentioned, we have the tools already, but we are not using these in such way - during the sprint plannings, nobody is not considering the units tests being the part of the actual implementation, rather it is considered as separate subtask, which is carried out before or after the implementation. So the team might not consider these differences, when for example sizes are estimated. Show
TDD for Embedded C Excellent The concept of mocks was new to me. Good balance Good balance Maybe it would be good to say some more words (background information) about CppUTest at the beginning of course. Excellent Much better Tight schedule that may not allow time for redesign. Show
TDD for Embedded C Very Good How little extra effort is needed to do TDD. Good balance Good balance Perhaps it could be a day longer to get even more hands-on TDD training. Perhaps this additional day could be used to apply TDD to some of our own programming tasks. Excellent Syntax highlighting default = on ;) The exercises were well explained and educational. Two thumbs up! Much better Yes. Not everyone is as interested in TDD. Show
TDD for Embedded C Excellent Mocking, did not have previous experience with it. Good balance Good balance Very Good Much better Show
TDD for Embedded C Excellent The thing I found most useful in practice is, make this simple in the beginning, it does not have to cover all use-cases immediately. I also liked the book recommendations, links and other resources given, for further improvement and self-study. Too many exercises Good balance It would have been nice if we spent a bit less time on what we found good/bad/surprising about TDD. A bit more digging into the specifics of embedded TDD, like more techniques on how to perform TDD when interfacing with ICs, mopre on how to handle memory-mapped IO. Very Good Vim-bindings :) Great pace, clear speech, entertaining. Much better Yes. We have many versions of our chip, with different properties. Our libraries are built to act differently depending (based on preprocessor macros) on which chip it is. It is hard to do TDD with these because we would have to run the tests compiled for different targets. Also, many libraries read directly from memory mapped IO, which makes them hard to test. Show
TDD for Embedded C Excellent Mocking HW for testing, and TDD itself Good balance Good balance Have an example/exercise on how to test legacy code Excellent Much better Yes, but I feel I'm not prepared to do the legacy part. Toolchains and a lot of different persons on the same code base. Show
TDD for Embedded C Very Good That my TDD practicing up until now has not been optimal: I did follow the Write test, Make it fail, Make it pass pattern, but I would apply this pattern in developing all expected features of a class a long time before they were were actually *needed* by the rest of the system. I.e. develop the entire class, including features I would not need until after (say) two more days of development work. (Premature development of APIs, e.g.) The risk in my old approach is to develop e.g. an API I may need to re-architect two days later. After this class, I will change this habit, and develop only what is needed right now by the code. Good balance Good balance Excellent I liked the fact that you bring up real-life examples from your own experience. Bring it on! Yes. None really, as TDD is already an accepted practice where I work :-) Show
TDD for Embedded C Very Good How small iterations could be made to advance the code and test in lockstep. Good balance Good balance Very Good Much better Show
TDD for Embedded C Excellent Good balance Good balance Very Good We stumbled a bit on the driver example. One of the issues we were debating was the separation between high level errors and actual device errors. I.e. the device signals VPP error but higher up all we get is a write failed. Interesting to listen to, very knowledgeable! Bring it on! Sadly not tomorrow, stuck in the design phase of a new project, not any code to write. None, we all believe TDD is good! Show
TDD for Embedded C Excellent Techniques for allowing testing away for HW. Good balance Good balance less time discussing the replies to our initial impressions/concerns/surprises Very Good Would have been nice to get closer to the silicon sooner Much better maybe - very pressing imminent deadlines, with no existing TDD framework, which would take time to develop. Hopefully very soon, and will be able to use some of the ideas in the mean time. We work extremely close to the HW (testing the HW). TDD will be very good for lib/framework development, but may not make sense when writing individual test cases (but maybe will). Show
TDD for Embedded C Very Good That embedded software is not so special as feared. The TDD way of approaching a problem was demonstrated very clearly. Good balance Good balance It is common that public course progress feels relatively slow during the first half of the first day. Though, I see that this can be necessary to bring everybody up to speed. Having attended your excellent presentation during the embedded accelerator day the day before made this more obvious. A list of participants annotated with company name and relevant experience and name tags could yield a presentation round unecessary. Participants have plenty of opportunitites to get to know each other during breaks. Going through the preparation answers of participants did provide topics for discussion, but seldom anything new to the destilled and accumulated experience of the instructor. Excellent Pair programming with complete strangers can be quite akward. It does provide the opportunity to discuss the solution, but it can also slow down progress. Considering how well the exercices were setup with comments about expected progress etc, I would prefer a combination of self programming, instructor demos and instructor personal guidance. Great presentation/teaching skills and sense of humor. A pleasure to attend. All exercises did illustrate new application areas and aspects of TDD. I wonder if it would have been better use of time to spend a bit less time on each exercise in the classroom so that we could have more use cases demonstrated. Bring it on! Show
TDD for Embedded C Excellent Various strategies in solving different testing problems. Many tips and tricks. Good balance Good balance Our course was more compressed than usual, and I felt that having more time for the workshop part would have been better. Also, if there was better overview on the code that we were working on, it would have made the exercise easier. For example, the home automation exercise on day 2 needed some understanding of the existing code and how different classes were intended to be used before doing the testing properly. Maybe such high level overview (ie. ULM diagram of different components/files, perhaps) would have helped to focus on doing the test case development. Excellent Well versed in the topic. Instructor provided good/detailed information in various aspects of TDD. Bring it on! Sure, we already have necessary infrastructure setup to get TDD going. Getting not only the buy-in from the management, but also the expectation that there will be slow down in the beginning. Show
TDD for Embedded C Excellent Focus on one thing at a time and iterate. Make sure to do it right while doing it via short feedback circle test-development-refinement. Good balance Good balance Excellent I struggled quite a bit to get the exercises going at ht beginning. A simple example in the exercises would have helped me to latch on fast. Much better I cannot. I'm a manager and not allowed to do much coding-:( But, I'll ask my designers to do it. Our business people want to deliver fast at all cost. They hate s/w refactoring because they are afraid that we might be in an infinite refactoring loop and do not release anything. Show
TDD for Embedded C Very Good The cycle of TDD Good balance Good balance it was good as is. Very Good Better development space (better editor) with at least a larger edit space, maybe syntax highlighting. Much better Starting today, I'm ready to drink the koolaid. Translating to python. Show
TDD for C++ Good Take smaller steps when using TDD. Good balance Good balance Drilling down a little more in the different patterns for refactoring legacy code. Then again, that is probably a different course in itself. Very Good Good job on explaining the material. Much better Sure. I've already been using the basics. Have a better understanding of mock objects. Just need to use smaller steps. The main challenges will be to refactor some of the legacy code for testing. Show
TDD for Embedded C Very Good How small the iterations in TDD should be Too many exercises Good balance Seemed like a lot of focus on how to unit test and mocking. This was not new to me so would prefer to break that out of the course. Very Good Good but a bit repetetive Much better Show
TDD for Embedded C Good Explanations of TDD and its origins and purpose. Good balance Good balance Make it an online course that lasts 2 days and no more. Good Moderately Show
TDD for Embedded C Very Good Exercises practiced in the class Good balance Good balance Include more embedded examples Excellent Not I can think of Bring it on! No. I am going to start it today. Show
TDD for Embedded C Excellent the basic concepts of TDD and use of the cpputest framework Good balance Good balance Excellent Much better Yes. I have various projects (embedded and not) that I can start applying concepts Coworker buy-in for team projects Supervisor supporting initial slow-down as concepts are applied Show
TDD for Embedded C Very Good CppUMock. Having had prior experience with TDD, mocking was the newest concept I saw and I can already imagine uses for it. It will definitely help me to develop cleaner code and better tests. Not enough exercises Too much presentation The part of the course on Agile was hard for me to make it through. Having worked in an Agile environment it was a rehash of things I was already fairly familiar with. I would have much rather preferred this time be spent on another exercise but I understand that my background isn't necessarily representative of the make up of the group. Very Good Bring it on! I plan on continuing to implement the concepts outlined in the course into my day to day work. The expanded capabilities of mocking I learned while here will be a huge boon to my testing. Push back. My code will definitely be written from the standpoint of a TDD developer but that might not be the case for everybody else; especially not right away. CI will definitely need to be configured for projects I work on to ensure the health of a build. Show
TDD for Embedded C Very Good How to actually setup unit tests, and testing methods (write tests first). Good balance Good balance More hands-on (such as going through the process of having existing code somewhere on your HDD, then finally get cpputest to run a test on that code). Excellent Much better I can. I know enough to start writing tests in cpputest now. Show
TDD for Embedded C Excellent Writing tests in CppUTest Good balance Good balance Excellent Much better Finding the time to start applying TDD Show
TDD for Embedded C Excellent The value of TDD Good balance Good balance Have the students write their own drivers as 'homework' and have them compare the TDD developed driver vs the typical development. This will illustrate the importance of TDD, as well as refactoring older code. Excellent Much better I find the application difficult to apply to my current project for a few reasons. Refactoring huge library of custom embedded code for a legacy architecture, RTOS, and many shadow-transfer mechanics. There are ways to develop with TDD for this, and I know where to find them, however, the learning curve right now is inconvenient for my project. When I start a project from scratch, I will use TDD as an excellent learning opportunity. See "Can you start tomorrow?" Show
TDD for Embedded C Very Good Well I did not know much about TDD so everything I learned seemed useful. I will try to do TDD on some modules to see how it will work for me in practice. Good balance Good balance Hmmm, maybe teaching a bit more about the framework itself in the beginnig. I was a bit confused with how it was working without any introduction. Very Good I think the exercises were good at introducing their concepts Much better Show
TDD for Embedded C Excellent "Have you got a test for that?" TDD will make my life easier, its not scary, it is my friend. Good balance Good balance A 15 minute break in the middle would be nice. Or maybe 2 10 minute breaks. This would allow everyone to stretch legs, grab a snack, use the restroom etc. I was able to run away from my desk a few times to do these things during the exercises, but I did not want to miss out on anything. If everyone knew the break was coming they could relax a bit more and focus. Then they would come back from break in a better position to focus. Very Good I do not code in C every day. For me it would have been nice to have the exercise on the second day be simpler, so I could focus on the TDD principles and not panic because there was a C programming concept I was struggling with. Or maybe keep the examples the same but jump in more often when you see someone floundering. You did do this when I asked for help (thanks). Sometimes people are too self conscious to ask for the help. It was great. I can never go back to not doing TDD. It will take me a while to get good at it. But I am determined to do it. Much better Yes, as you taught us, incrementally and methodically. Getting good enough at it, that I can evangelize the practice. I won't have a problem getting it adopted if I can lower the barrier for entry to others. I will be recommending your class to others that we will be hiring soon. Show
TDD for Embedded C Good Cppumock looks to be a very useful framework for what we need. I enjoyed the exercises and the chance to write C after nearly 20 years away from it :) (I came into the course with lots of automated test/mocking experience and some slight TDD. But attended alongside my 3 colleagues to help etc). Not enough exercises Good balance If you plan to skip slides, don't have them (they can become notes in slides for attendees if you think they have use) More exercises (see below) Very Good The exercises were the best bit of the course. However I felt that day one would have worked better with some tiny exercises to illustrate the cycles of TDD better. Something like "min of a series of numbers". Similarly a tiny small mocking example to start day 3. I felt at various times that you are under-prepared. Day three afternoon was an example of this - the walk through of your RTOS and legacy were poor. You looked surprised too many times and without concrete examples (exercises) it felt little more than being shown the results of a google search. The other example was the question board. I felt that in you afternoon you could have looked at the questions and then come along in the morning ready to give stronger and shorter answers to each questions. Moderately Yes Finding the right work to get early wins. TDD also fits in well with our functional safety work where we must get 100% code coverage. Show
TDD for Embedded C Very Good The general practice of TDD. Also, I found the use of CppUMock helpful as it seems better than other mocking frameworks I have used and it is free. Not enough exercises Good balance It could have been helpful to spend the first day on many little exercises to train us on how to start new TDD projects and to get into the habit of creating a programme by writing the tests first, the second day could have been circular buffer, and the final day as it was. Excellent More but smaller exercises on the first day. Knowledgeable, friendly, and helpful. Much better Not full TDD as I am currently just working on legacy programmes so there will be a lot of work first to move into a test harness. I am also writing tests for completed code with no more development left. Legacy code. Show
TDD for Embedded C Good Learnt through exercises how to apply TDD and mocking frameworks. Good balance Good balance More simpler exercises which allow quicker application of TDD. I would have liked more discussion on testing RTOS. Good Not so complex as a starting point. Overall I found the presentation fine, but, for me, I found it was not well focused on the subject at times and did drift off on the odd tangent subject. Moderately Probably not yet, need more practice at applying TDD. Given the time and space to apply it, learn how to do it better then re-apply it. Show
TDD for Embedded C Very Good The techniques required to improve my software development Not enough exercises Good balance I can not think of any changes. Very Good More simple exercises on day one, use the circular buffer for day two and leave the day three exercise as it is. Very knowledgeable Much better Yes None, our management is 100% behind the idea. Show
TDD for Embedded C Good Good balance Good balance Very Good Much better Show
TDD for Embedded C Very Good The most useful thing I've learned is the concept behind TDD. This is a great way to build your functionality even when you don't have all the requirements clearly defined. Good balance Good balance Excellent Much better Yes I can start right away, because this can improve my work results greatly. The main challenges are process adherence by using this method. Some strict processes require documentation as output products, for example having tests planned, defined and then test reports stored and linked to the requirements. Show
TDD for C++ Very Good About usage of TDD, Build and test enviornment. Good balance Good balance Very Good Much better Show
TDD for Embedded C Very Good the idea and the way to develop TDD code Good balance Good balance Very Good Moderately Show
TDD for Embedded C Good Mock object usage Not enough exercises Good balance I could understand the concept, but still not sure how much it can improve in the actual development phase. I like TDD and want to introduce in actual development, but still feel difficulty to convince my colleagues. Good Exercise was good and step by step was interesting. But it make me feel uncomfortable like going blindly. It will be good if I can see a plan, forecast for the amount of required test cases etc. Demonstrating writing code was a little bit long Much better No. Current codes are too messy to divide to testable size. Too many dependencies. Need test environment design and development. Same as above, and also to let everyone in the team to understand the concept and follow the coding style. Show
TDD for C++ Good Code coverage through creating test environment during design well before implementation Good balance Good balance By demostrating an example of a situation and providing a situation as a homework on work on from scratch. Good By demostrating an example of a situation and providing a situation as a homework on work on from scratch. Thanks for making the session interactive. A little No, I would need more time to understand how and when to apply TDD. My current project is almost in maintenance stage and may not be a good idea to change my approach at this stage. Show
TDD for Embedded C Good CPPUnit, Manual testing is not sustainable Good balance Too much presentation more focus on how can it be be applied to specific component. I want to use TDD (CPPUnit) for kernel components, but yet confused how should I use. Many of our domain codes (bootloder, kernel, device drivers) run in their own environment and difficult to test from user space. Good I think exercise should be smaller. good Bring it on! I want to use it right away. This is need, only thing for me is how can I apply it for my module. CPPUnit being c++, not sure how to link with kernel and bootloaders, but will investigate more. Show
TDD for Embedded C++ Excellent Testing before development. Good balance Good balance Excellent Instruction was very interactive. He explained with example which made us realize the requirement for having TDD . Bring it on! I would rather like to start today. But we have time constraints and other activity. I would always like to start is as soon as possible. Show
TDD for Embedded C Good TDD at its best is a quick, tight loop of [modify, test -> fail, modify, test -> succeed ] Good balance Good balance I feel I missed out on any experience of TDD in the later stages of development. Obviously you can't throw a complicated and extensive implementation at a workshop and have trainees feel that they are making any progress within the first hour or two. But you could *demonstrate* later state development with an implementation you are familiar with. In particular, I would have liked to see dealing with issues like these: Reworking the external interface of an implementation. Completion of test (ie when have I tested enough). Maintenance (ie version 2.0). Very Good Skip ahead in the process to a step with a more complete implementation. (Maybe a few of the participants made it far into the implementation, but I think those following the rules of TDD "don't write code until you have a test for it" and "add one test at a time" would not.) Eg have the circular buffer complete up to a point like "works until you add when it is full" and start TDD from there. Or, works perfectly, now make it so it resizes larger automatically up to some size. Excellent. Well prepared. Sometimes I think you brushed off my concerns without really understanding them (and certainly not discussing them) because they weren't on your agenda. Bring it on! Sure. I would absolutely try this immediate on a new design that I feel is suitable. I'm still not convinced that it is worth wrapping some designs in test, and these are ones I'm working one. In particular, designs where you don't know the required behavior until you actually do system test, and/or designs where the complexity of the external interface is large compared with the actual code implementation. (These are probably the same as cases where the size of the test code--used and obsolete--is orders of magnitude larger than the release code.) See above. Lots of legacy code with complicated interfaces. Many cases where, yes, the legacy code is the spec, but I already know it is bad and I'm throwing out the spec--particularly when the code I'm replacing is much more complicated than what I'm replacing it with. I'm also deeply concerned that there will be a false sense of accomplishment: the most costly problems I see in bad designs are poor factoring and designs that only solve part of the problem--at the system level. TDD will probably influence bad programmers to do better factoring, but in general is not going to fix these problems. And after you have a large and powerful test wrapped around components of a bad design, will people have the guts to throw it all out, as they should? Show
TDD for Embedded C++ Very Good All of it was useful to me due to my limited programming experience. Good balance Good balance I'm not sure. Very Good I'm not sure. I enjoyed the way he presented the material even though most of it was still over my head due to my limited programming experience. Much better No as I am still very inexperienced with programming and would need some help to get started. Just learning my programming style to then implement TDD into it. Show
TDD for Embedded C Excellent The practice of coupling production-code development with writing test-code that exercises said production-code. In hindsight, it seems like this should be a fundamental part of programming, taught from the very beginning. Good balance Good balance If you could find a way to spend less time battling people who are resistant to the concepts of TDD. It felt like a lot of time was spent in fruitless debates where attendees just wanted to keep doing things their way. I understand that this isn't your fault, and the fact that this is my only complaint is really a testament to how good the course was. Very Good The exercises were good. Perhaps let the attendees know that they are free to implement an struct where convenient, BEFORE starting an exercise where one will be used. Engineers hate doing irrational things, and it is disrupting/frustrating when we find ourselves creating separate variables instead of passing around a nice little struct, only to later discover that a struct is permissible. James' mastery of software engineering is admirable, to say the least. It inspires one to open their mind and trust what he is teaching. If you have a doubt, or an approach you think is better, he will invariably have the perfect anecdote to highlight where you went wrong. He keeps the course on schedule and seems to care a lot about what he is teaching. Bring it on! Yes. The course did an excellent job of highlighting the problem (bugs, difficult-to-manage code, poor test-coverage), detailing the solution (TDD), and walking the attendee through every part needed to start implementing tests independently. Setting up the development tools to work with CppUTest can be a massive headache. At the time of writing this, I still don't have a functioning environment for building tests on my machine. Show
TDD for Embedded C Very Good The importance of doing as little as possible and not jumping ahead of your tests. Specifically for the reason that you write untested code that way. Good balance Good balance Very Good Much better Yes, since we are already in the process of moving to an improved code base. Mainly the support and buy-in from fellow developers. Some think there is no purpose to TDD. Some like it, but think it takes too much time. Others like it but don't think our management/sales force will accept the added time needed to make tests and deliver a tested product first then a slightly buggy product. Show
TDD for Embedded C Very Good New approach and way of thinking when designing and implementing software = TDD. Good balance Good balance Excellent Much better Yes, I will try to. Legacy code infrastructure (getting compilers and unit test frameeorks to work) Show
TDD for Embedded C Very Good How TDD can be useful. How to integrate it in my legacy code. Good balance Good balance It's already OK. Excellent / Instructor was very adaptive to our needs. Clear in explanations and helpful in exercises. Much better Yes, I got every information I need to start using TDD tomorrow with a little bit of extra effort. Switch to a different mindset while start coding production code. Start seeing my legacy code from a different point of view. Show
TDD for Embedded C Very Good TDD methodology Good balance Good balance Need more time Excellent Don't need to Excellent knowledge Much better Can't start tomorrow because in into research project without coding Cpputest on build server is challenge Show
TDD for Embedded C Very Good Introducing TDD in my code, test doubles and mocking the silicon. Good balance Good balance Improved presentation design. Very Good Insert small exercises during a presentation, up to 30 minutes of exercises for one hour of presentation. Experienced professional with a lot of desire to transfer knowledge and experience. Much better Without problems. Probably the biggest challenge will be code refactoring. Show
TDD for Embedded C++ Very Good Good balance Good balance Very Good Much better Show
TDD for Embedded C++ Very Good building code in parallel with the tests. Simple concept but never occurred to me. Good balance Good balance The class could be improved by adding some material that would help adopters facilitate the maintainability. Suggested turn-key templates that helps how to keep the tests up to date with code changes. Mechanisms to ensure test harness is run with small incremental changes. Anything that avoids having to rely on developer discipline. Good the prepared circular buffer was good. I suggest having a prepared legacy example. Working in our own code is a good idea however it was lengthy. Adding an example that would allow developer learn how to restructure a legacy into a more testable would be greatly beneficial. Thanks James, enjoyed and learned new skills that I intend on using. Much better Yes, however I would only tackle a small scope features. In an organization as Panasonic it's not uncommon for one group to have little understanding or what the other groups are doing. I can see that code changes might require other groups involvement for stubbing and test case definition. How to get other group resource support could be challenging. Show
TDD for C++ Very Good Good balance Good balance Good Much better Show
TDD for Embedded C Excellent automated testing is a must, not an option for large scale software development. Carefully crafted code from testing is sustainable for cost reduction Good balance Good balance can't see the screen clearly for test code parts. Excellent Good control of timing, presentation and discussion. Group exercise is really helpful. Much better Will start tomorrow. It's a good practice code base is large, dependency is deep Show
TDD for Embedded C Excellent Prior to the training I was unaware of the scale of testing performed when TDD is implemented correctly. After the training I was able to report more accurately on the benefits of implementing this in our development cycle. Good balance Too much discussion I'm not sure it would fit in the two days allowed, but in addition it would be great to spend more time on implementing TDD in a new project. I would imagine this would involve learning more about the test harnesses, and an example of starting a brand new project with a test harness. Excellent I can't think of any improvments Very qualified to teach the course, well prepared for the training session. The discussion would wander infrequently, but when it did it went a bit off topic. Much better I would love to start tomorrow, but I think I would have to hire a consultant or trainer for a short time to get started on the right foot. Some of that may be my lack of prior knowledge of test harnesses, and general principles. I wouldn't be able to spend the time trying to learn it myself when it could be accelerated by assistance. Just the new learning curve, and assistance to get started. Show
TDD for Embedded C Excellent how TDD works and how TDD is used for embedded C. Good balance Good balance If spend one hour on setup environment as a workshop, it would be better Excellent good very good Much better need some time; we need more time to setup; and choose right project to start with. environment setup Show
TDD for Embedded C Very Good The incremental way to develop by creating simple tests first, then implement only enough of a solution to pass the test, then create more complex tests, etc. Good balance Too much presentation A little less lecture and talking about tangential topics, and more focus on the core information of the course. More time on the HW mocks would be good, as that is a really big area for most embedded systems. Also, some presentation on how to implement when doing cross-platform development. Good Entertaining and enjoyable to listen to. He obviously knows his stuff and is an expert in the field (as are all Barr Group affiliates). Moderately No. The learning curve is too big, and my existing workload is too great to allow the time I need to start to implement. I have to look for the right project to try it out on. Getting buy-in from my manager that the extra time now is worth it. It will be easier to do it at the beginning of the next project, not now near the end of the existing project and the hard deadlines we are facing. Show
TDD for Embedded C Excellent Good balance Too much presentation Excellent Much better Show
TDD for Embedded C Excellent I think the most important thing is just going through the process and seeing that it can work. Reading about TDD just isn't enough. Good balance Good balance Excellent Much better No, but we can start taking steps to start. Our current codebase uses three languages and multiple frameworks with generated code. Everything is very tightly coupled. I think TDD will allow us to refactor a lot of this but not tomorrow. See above Show
TDD for Embedded C Excellent How TDD establishes a cause and effect relationship. Good balance Good balance Reading through the registration questions and other feedback during the course felt a little too time consuming. Very Good Exercises could be improved by varying from the exact examples in the book. Extremely knowledgeable and helpful in explaining TDD concepts. Bring it on! Yes, management approves TDD and the tools are available to start using them immediately. Schedule considerations may determine the extent to which TDD is applied to legacy code. Show
TDD for Embedded C Very Good Good balance Good balance Very Good Much better Need to have time approved for the initial work. Show
TDD for Embedded C Very Good Not one thing in particular, but it was useful to be immersed in a mindset for two days, and be encouraged to see what is possible, and the possible ways it can be used. Not enough exercises Too much presentation Very good overall. Though James is entertaining and engaging, there could have been a touch too much presentation and discussion. Excellent They went well. James is entertaining and engaging, and brings a lot of insight and experience via a wide variety of stories and use cases. Much better Probably! The starter kit is nice to have. Cultural entrenchment. Show
TDD for Embedded C Very Good 1. TDD benefits in firmware development 2. A tool, CPPUTest, is available for embedded programmers to use 3. First hand experience by using CPPUTest Good balance Good balance I wish there are more examples related to the embedded system. Very Good More complex embedded system exercises are needed, which can demonstrate TDD benefits. knowledgeable and helpful Much better I am working on the legacy codes that were developed by previous developers. The changes I made are not in module level. The changes are for the system process. I need to know how to apply TDD for the process of embedded system. You have not touched these kinds of topic in the two-day training sessions. Legacy codes are done by other people, in which there are a lot bandit bug fixing codes without any comments. Show
TDD for Embedded C Very Good Applying TDD through CPPUtest Good balance Good balance I struggled a little with the discussion of the concepts. Perhaps the instructor can slow down a little. Excellent I think the exercises were great & well-thought out. I struggled a little with the discussion of the concepts. Perhaps the instructor can slow down a little. Much better Yes, my team has already started using TDD. Working with legacy code Show
TDD for Embedded C Very Good Getting my hands on how to and where to apply this tec Good balance Good balance Add More days Very Good Moderately NO . Work environment is to difficult to add or change. Changing environment & changing the old or current codes Show
TDD for Embedded C++ Excellent Adding tests beforehand is not an overhead. On one hand, it prevents degrades. On the other hands, it challenges us about the required behaviors before we delve into the actual implementation. Good balance Good balance Excellent Much better Yes. I've completed the unfinished exercises. I'm setting up the build environment. I will convey what I learned to my team. Concept change - requirements and software can be evolved in a spiral way, thus the approach (tests and implementations) with which we achieve them. At my workplace, sometimes we wait for requirement clarifications without starting from known points (thus a time loss). Other times we did the implementations too much without re-considering if the implemented behaviors match the requirements, or they can cover reasonable error cases. Show
TDD for Embedded C++ Good mocking(flash driver) Good balance Good balance more hands on examples and providing benefits of TDD. Very Good Much better Already started. threading, exceptions, third party API's timing behaviors. Show
TDD for Embedded C Excellent how to do wax on and wax off for the code being implemented. Good balance Good balance doing more exercises to explain concepts of TDD. Excellent Moderately Show
TDD for Embedded C Very Good Assumption it is cheap faster easier to fix bug earlier in the process than later. The best value is to discover real bugs as early in the process as possible. Good balance Good balance TDD is not a cure all for bad practice. Touched on in final discussion. Some coding is just plain bad practice. TDD is not a Panacea against it. Cyclomatic complexity, LOC in a routine and so on. There needs to be an up front expectation of reasonable coding practice. TDD is a tool in the box not a cure all. For example - the real constraint at Panasonic is - people do not understand what is required. Assumptions are made - that may be wrong. Real understanding does not arrive until customer objects. Also there are some inherently automotive challenges - Initialization and shutdown. THese deal with runtime behavior and system level behavior. To me TDD is make sure what I 'know' I want to do, I actually do. What I want is to do this part right, then understand analogous step to transition to integration test - with a methodology similar to TDD. and scale up from there. Very Good They are good. FIne Much better Yes None Show
TDD for Embedded C++ Excellent The way of approaching a feature design and development has to change. Test cases would drive the feature development, than functionality driven. Good balance Good balance One more day could have been added to get into the codebase that we work with, and get solutions for the real code. Very Good Much better I can start from tomorrow. Show
TDD for Embedded C++ Very Good How to do TDD. How to apply it to my work. Good balance Good balance Excellent Moderately Show
TDD for Embedded C++ Very Good How we can fake/mock the hardware or timers dependency Good balance Good balance Some of the sample code had dependencies on cpputest etc. Giving more info on dependencies would help. Very Good Conveyed the concepts very well. Much better yes I'm mostly working on legacy projects or projects in maintainence. The code is already in production and hence do NOT see value added in writing unit test cases now. Having said that, as learning experience I will develop test cases for existing sorting algorithms though it still doesn't become tdd. Show
TDD for Embedded C++ Very Good How to catch early defects. Good balance Good balance Very Good Moderately Show
TDD for Embedded C Excellent How to implement Object Oriented like code structures using C capabilities. Good balance Good balance Excellent Much better Well, I still don't have much experience with embedded development so probably not. Show
TDD for Embedded C Excellent Mocking and stubbing in C and the steps for refactoring C code. Good balance Good balance Since we don't really get to work with embedded systems at 8th Light I would have loved to work build a project using TDD and then deploy it to an embedded system and see what kind of changes have to be made to make the code work on the given platform. Very Good I really liked all the exercises! James is very good at making software concepts interesting to talk about. I was able to pay attention for the entire course. Much better We don't have much work with embedded systems at 8th Light, but if we would I would love to be on one. The lack of embedded projects. Show
TDD for C Good The main idea here is very good,let the tests define the code,+ zombie pattern Good balance Good balance It was hard to work with the tasks getting interrupted over and over again Good Less participants Moderately Show
TDD for Embedded C Very Good The method of using TDD for embedded software Good balance Good balance This course is great. We could possibly spend a little longer, performing TDD on our existing code Very Good Moderately Show
TDD for Embedded C Good How to do a Mock to simulate the hardware for a Device Driver Good balance Good balance Possibly a slightly better "flow" somehow. Maybe also a better agenda upfront with an idea of what we will be doing at what time (roughly), helps to schedule breaks etc. Excellent I thought the exercises were ideal Professional yet informal. Knowledgeable and easier to talk to. Bring it on! I have also ready started the process of writing unit tests before a new block of code. It actually seems to work! Only persuading some managers that more time upfront will cause a huge time saving later on. Most of them agree in principle anyway. Show
TDD for Embedded C Good It should not take much longer to develop code using TDD. Especially in large SW projects. Growing code takes longer and longer to test. TDD can be learned ;) Good balance Too much discussion It was a bit confusing sometimes working at the exercises and beeing interrupted many times. I think it would be better if you give some fix time slots for the exercises. Very Good ok so + Very interesting stories. You have a huge knowledge of the whole stuff and I think that was the reason I learned quite a lot in only three days. Thanks a lot. - If you explain something for one person it may be better to connect you and the person directly if this is possible. I found it quite annoying when doing the exercises. Moderately No not really. I have to practice TDD much more first. Also we have to think how we could start in our company... time pressure, a huge amount of legacy code (some is very old and poorly programmed), have to convince the management of TDD Show
TDD for Embedded C Excellent CPPutest provides some plusses over Unity. Also reinforced just how much I still have to learn about/practice in C. Good balance Good balance Excellent Much better Yes, already have started using TDD in a combination IAR & GCC build system. GCC to build/run tests, and IAR to generate firmware for a Silicon Labs Zigbee module. Show
TDD for Embedded C Very Good How to use mocks to isolate test objects. Understanding that code often must be refactored first before implementing tests. Good balance Good balance I would like to have some short breaks to be able to reflect/discuss and to keep a better focus. Very Good I would like to split the exercises in to smaller parts. Specially the exercise in day two (light scheduler). Very competent and experienced. Good speaker. Much better Yes, at least a small first step... Get the time to do it the right way from the start, like the lego-guy trying to put wheels on the carriage. Show
TDD for Embedded C Excellent How to do TDD all way through by taking small steps and only making one simple change at a time. Good balance Good balance Maybe by including some real life examples on TDD where it has been used in a larger project. Very Good It would have been nice with an example for the following cases: * legacy code example - add and/or change a feature in a legacy system. * Include a bit more architectural decisions. I.e. start with a problem, then suggest a solution and then TDD the suggested solution. This is especially to make it clear whether the TDD approach effects the architecture in a certain way. Moderately Yes, I think it is important to start right away to get the most benefits. I may need to start out with getting some tests into a legacy project, but I will also try to continue with some toy examples to get more used to the approach. Legacy code is probably the biggest challenge, but I believe the appropriate tools have been provided to handle this case, but I still need to try it out myself. Show
TDD for Embedded C Excellent "Please slow down, we're in a rush." Your training was a great reaffirmation of that. Good balance Good balance For me it would have been much more convenient, when the personal discussions during the exercises (while you were answering questions to panda or deer or,...) audio would have been muted for the rest of the class. I felt like I have to listen all the time because you were calling out names. It gave a lot of interruptions. Too, this caused me to withhold a few small questions. I guess it is a webex problem. Maybee you find another way to signalize when you want to talk to everybody. So individuals can mute the speakers. Very Good I am impressed about the frameworks and how smooth the exercises are working. Cant see anything to improve right now. Very personable that you turned on your Webcam during discussions. Liked it. Well presented. I felt, that you intention is to help me. You're authentic. Really apreciate that! Much better Yes. Why? When to plant a tree?! I go through the legacy list on your website. 1. Boss and/or teammates who refuse. 2. Time Pressure. 3. Fear of the Framework/Process. 4. Often Changing projects and customers. --> For point 1 I found a solution to handle that (thats why I was able to attend) --> For Points 2,3&4 I'm now convinced that they can't be an excuse. Show
TDD for Embedded C Good To change the code in really tiny steps and never add more functionality than required. I've worked with unit testing before but not with the TDD mentality. Good balance Too much discussion Good Sometimes the exercises were a little too long and we ended up focusing more on code details than the test concept that had been demonstrated. Much better Yes, we already have some unit tests and I'd like to start by refactoring them according to what I've learned in the course Slow building times makes testing really inefficient Show
TDD for Embedded C Very Good Concepts Good balance Good balance In depth on the concepts Very Good More time Good Much better Yes Have more Legacy code Show
TDD for Embedded C Excellent The TDD workflow, writing code in small increments by keeping up with the unit tests written. How to convince skeptical developers to adopt this. Good balance Good balance The 'live coding' portion where attendees watch the instructor code and test could be longer, with the instructor explaining more in detail his thought process Excellent Break down exercises in smaller steps with checkpoints in between Bring it on! Yes Getting developer buy-in for the extra effort to test up-front, rather than at the end Show
TDD for Embedded C Excellent Personally I felt I learnt most in the area of step by step refactoring. I think I have been doing the right things but still taking too big a step. I was also well reminded of the importance of good names. Good balance Good balance I wonder if a few slides on version control and CI would be beneficial. In CyberDojo it is easy to step back if a small step goes wrong, how to step back outside of cyberdojo, may be able to use editor, may want to very frequently commit. Should this be to a local branch or pushed (I'm thinking git). As far as CI, I think it could help to show what tests run on a build server look like, and how metrics could be used. I also wonder about touching on code coverage. Personally I usually enable gcov within UnitTest applications. I don't tend to worry about the level of coverage, TDD keeps that high, but on bug refactors it can help to see that functionality hasn't been inadvertently added. Also I find it useful when bringing in legacy code - it helps to see that you have covered the bits of code that you think you have. Excellent I wonder if there is a way of splitting the longer exercises by holding back a little of the prep material and injecting it part way through. I'm not sure if this would help or have a moire negative impact by stopping people getting in to the TDD flow. I personally find your style easy to learn from. You make your points well and obviously speak from experience. Bring it on! No - I started using TDD regularly on the 31/10/2012 the last day of the first time I went on your course. I will continue to improve. I have real trouble performing TDD in IEC61131-3. For TDD on embedded C/C++ the only problem I face is persuading some customers of the benefit Show
TDD for Embedded C Excellent I am starting with professional software development so it is crucial to me to learn anything about testing. Good balance Good balance I think the only issue for me (and it seemed for others as well) was that we proceeded to write code without fully understanding/thinking new concepts through and this way we dug a hole that was difficult to get out from. It was somewhat an inconvenience. There could be an optional pre-training warm up exercise to brush up syntax and C concepts. I had a 2 years break from coding (deployed to Field in Saudi Arabia) so I did read a little to refresh but it would be nice to have some practice that would help me see if I am ready or not. I was alright and I did get help to with malloc/free but perhaps the course could be more accessible to people who were not familiar with C/C++ in the past. Very Good I like the exercises but it would be great to know exactly where I am supposed to code certain functionality. I had to rollback two times for placing code in wrong spots. Despite minor issues, the coding helped me a lot understanding the concepts. Perhaps, it would be good to have a completely abstract first exercise that only asks what to do, when and how without coding and then proceed to the implementation so that these two dont mix together and we dont get ahead of ourselves. The course was very well presented - clear, easy to understand English, concepts appropriately illustrated with the slides. Funny pictures, relevant quotes. Quality work overall. I really like that the first hour every day was just lecture - because it was too early for me to actually write meaningful code. Bring it on! Yes, I will start using the concepts - it became a requirement for Schlumberger and I believe that every new Embedded Software Developer (fresh grad) is now obliged to undergo this training. Still, our hiring numbers right now are relatively low until the oil picks up. We are using LabVIEW and NI platform to deploy the current generation of surface and acquisition equipment for our new fracking system. SO it is a challenge to migrate all these ideas to graphical programming but we have expertise within the team so the next step is internal training on how to do it to fit the purpose. Show
TDD for Embedded C Very Good test doubles overview of tdd legacy code Good balance Good balance Very Good Much better Yes. Understanding the purpose of TDD and how even legacy code could be placed into test harness (with hopes to refactor for the better). As stated...tight project deadlines with growing/extending legacy code. Show
TDD for Embedded C Good The basics of TDD Good balance Too much discussion Maybe need to emphasise more the understanding requirements and doing a test list before the first exercise. I became too engrossed in the mechanics of using the test harness without thinking what I was actually doing Good I found the exercises initially difficult as I didn't know the test harness at all. Initially I found myself doing the exercises mechanically without really understanding Fine Much better I would like to but short term goals will get in the way. Making sure I have the time to learn and improve my skills without short term time pressure. Show
TDD for Embedded C Excellent Hands-on examples showing how to get started. Good balance Good balance The exercises were hard enough that the interruptions set me back quite a bit. For novices, the exercises could be probably be broken up a bit. The demonstrations designed to prime the exercise were too big a step for me. Perhaps a few micro iterations to ease into the exercise. This may be a remote course challenge. In person or with a pair partner might have addresses this. Excellent see above. I really like the exercises themselves. Clearly a leading thinker and practitioner in the field. Much better Yes Show
TDD for Embedded C Excellent Test, test and more testing I program so I write bugs. Good balance Good balance Very Good the exercises are okay. I think having the material to setup the exercises before the training would have been better for me. James was very Patient and knowledgeable in TDD and he did a very good job of presenting the material. Much better not really. Like you said I have to continue on my present path and release the product to satisfy the schedules i have to get approval from management to allow the time in the schedule Show
TDD for Embedded C Very Good How TDD will require a different mindset/approach to developing software compared how we accomplish this today. It will also take time for the team to become proficient in this. Good balance Good balance Not sure, I thought it worked well. Very Good No, I think they got the point across He was fine. Moderately TDD will require a different mindset/approach to developing software compared how we accomplish this today. It will also take time for the team to become proficient in this. see above Show
TDD for Embedded C Very Good Good balance Good balance Very Good Very knowledgeable, and excellent delivery of the material. Much better Cost-benefit analysis of applying the concept as company policy will likely be required. Show
TDD for Embedded C Very Good The idea of only writing the code you need for the tests youa re running. Good balance Good balance The only way to improve it is to add another day to it. It seemed a bit rushed, but that may have been because of the time constraints. Excellent No changes needed. The instructor did a fine job in explaining the concepts. Much better Possibly. I am one of the newer employees and am just learning the code. I will start by trying to use cpputest to demo debugging of one of our functions. convincing others to apply them Show
TDD for Embedded C Excellent TDD - Red/Green/Refactor Good balance Good balance Smaller groups for even more personalized experience. Excellent Print out instructions and test information, so that scrolling and window switching is kept to a minimum. Well prepared. Much better Yes. I am looking into getting the Test Harness going for C#. Time up front. Need time to learn the tools and the harness. In the long run, time will be saved. Show
TDD for Embedded C Excellent The framework and method to drive development from test point of view. The procedure in development phase will improve module/component quality before TnV phase; and reduce bug fix time especially after integrated into system. Good balance Good balance Provide some successful real use cases. Very Good For the last day exercise, you can share a VMWare image of Linux/Windows that pre-loaded with compiled cppUTest and Starter project. The image maybe big, but easily copied through jump drive during the first days training. It will save the setup time. The VMWarePlayer is free download. Knowledgeable, patient and skillful! Moderately Will try on existing module, it's fun. Like in the last exercise, multiple-module system testing is challenge. My opinion it works better for module/component development, the earlier stage the better. Show
TDD for Embedded C Excellent I have been doing TDD since the turn of the century and it does have tremendous value in terms of finding defects early and often as well as mitigating the huge back end costs of retest or regression test. What I liked about this formal training is the idea of first writing the unit test to fail to achieve MCDC from the beginning. I am going to incorporate this into my work habits. My hope is this company Zebra encompasses this approach in every day software development. It will really improve quality and decrease development cycles. I have seen it first hand at other companies. Good balance Good balance I thought this course was excellent. It covered a tremendous amount of information in such a short period. I have no suggestions for making this better. Excellent Again the exercises were excellent. No suggestions. James seemed highly experienced not ONLY in implementing TDD and Agile processes but a highly experienced software engineer who has excellent verbal and written communication skills, which is rare. Bring it on! Yes I have been practicing this methodology for the past 16 years. The ONLY issue I have is once I get target hardware I drop it. This course provided a framework on how to get the entire software department into this practice from the beginning of the development cycle, and stick with it from concept to deployment. I was also never formally trained so I learned new concepts that will only enhance my skills. It is a different way of thinking. I find that even though I have been practicing this TDD methodology for the past 16 years for myself, I always find myself going back to writing code from data and control flow and not from unit tests. I think the reason for that is I never found a company that has embraced this method, and it is difficult to change a culture by yourself. Show
TDD for Embedded C Excellent Ability to write test code easily with CPPUTest Good balance Good balance Excellent We may need to spend more time on legacy code. You very well prepared and had all the tools like fff, exploding fakes scripts etc which are very helpful. More such tips on how to get the legacy code compile will be useful. Bring it on! Yes, because we already got introduced into how to deal with our legacy code Getting the code working on off target PC platform. Still undecided on whether to use Visual studio or GCC. At this point, I feel GCC is better Show
TDD for Embedded C Very Good Good balance Good balance Very Good Moderately Show
TDD for Embedded C Excellent I understodd the philosophy of TDD and how to use it in my projects Good balance Good balance Excellent Much better Technically yes... I am 1 or 2 weeks away from starting my new project so I will start TDD with that one! Not many really... maybe just setting up the environment...that's all Show
TDD for Embedded C Excellent TDD principles. Good balance Good balance No suggestions. Very Good No suggestions. Excellent. Bring it on! No. Believe will have a internal team meeting about using TDD first. Show
TDD for Embedded C Excellent fff & MOCK keep in mind I already had exposure to TDD via an Awesome Out of this world book written by the one and only James W. Grenning ;-) Good balance Good balance We kind of spend a lot of time fiddling around getting the projectors and test environment up and running. Good A single MOB group was a too many people. Projectors basically sucked. Awesome. You could project little more(as in talk a little louder). Bring it on! Yup. Looking at fixing my test harnesses this afternoon. Nothing. Show
TDD for Embedded C Excellent Understand how a unit test should be performed. Good balance Good balance Not much. I'd wish we have more days to learn from the instructor. Excellent I am not a big fan of paring up with other people when doing the exercises. I like the mobbing concept nonetheless. Excellent. Much better No, I am on a more hardware related project at the moment. I would like to explore TDD on my own. It seems that I am usually only involved for a limited time of many projects, and most of the stuff I write is tightly linked to the CPU hardware. Therefore if I start using "fake functions" then probably not much left for unit testing. Show
TDD for Embedded C Excellent I can apply the techniques I have learned from TDD in application development in embedded C. Good balance Good balance An engineering technique cheat sheet specific to Unity and CPPUTest. Excellent Able to relate, which makes him more authoritative. Bring it on! No. I do not use C normally. Winning minds. Show
TDD for Embedded C Excellent CppUTest. Fakes and Spies. fff framework. Defining TDD tests by selecting "Fastest Path" through function under test. Create next test and repeat until all paths are covered. Good balance Good balance Spend a couple more hours on mocking hardware. Excellent Add more HW mocking. Clear in communications, fun to listen to. Inspiring. Good pragmatic software craftsman. Bring it on! Yep! Unfortunately I'm not exposed to 'C' in the mob, but I will certainly use this in my Raspberry Pi projects ;) Show
TDD for Embedded C Good TDD can cut down on Bug fixing cycles by integrating testing into the code generation part of the design. Too many exercises Good balance Day 2 was horrible, and I don't know what could fix it. If Tom hadn't already been to your course and been through it, I would have probably written TDD off on that day. Good It's too easy to get bogged down in the small details of the exercises and waste time. I think it might be better to do individual exercises on the last day of class. All other days we should do the exercises together so that we can get some hands on experience while ensuring that things are moving along. The instructor was very vigilant about making sure people were making progress. This was appreciated. The instructors teaching methods just didn't make it easy for me to learn. I appreciate a traditional method where you "tell me what you're going to tell me", then you "tell me", then you "tell me what you told me". But that's just me. A little No. Too many deadlines. Finding time. Show
TDD for Embedded C Excellent The most useful thing I learned was that there is already a clearly-defined series of steps to go through from unit-testing plain C to TDD with embedded code. Good balance Good balance One thing I missed -- perhaps it was covered -- was that different authors use different terminology for testing. So words like "mock", "fake", "spy", etc are overloaded. Excellent The material is great. Having folks pair up throughout the exercise would make it better, but I'm not sure how you do that with an online course. James did an awesome job! It was like having him here in the office helping out. He was very responsive to questions and took his time to explain concepts that might have been difficult to grasp. Bring it on! Yes! As an instructor myself, I cover so many topics that by the time I get back to this topic, I'm likely to be cold on it. Show
TDD for Embedded C Very Good ZOMBIE method to thinking about testing Good balance Good balance My Colleagues were intimidated at with trying to understand the concepts of the tools while trying to dig into doing the exercises for TDD and were frustrated. I was too the first time I took this, but being familiar, it was much easier the second time through. Perhaps a little more high level introduction to using the exercise space (Cyber-Dojo) would be helpful. Very Good Perhaps break them up in smaller pieces with discussion in between. I think some of the conversation was verbalizing what was going in your head. At times I couldn't tell if it was for his benefit or ours? Sometimes it sounded like he was confused. Clearly indicating what should be going on in our thinking process would be better. Bring it on! No, Backlog of work from being in training 3 days and a pending release of code this week. I will be trying to squeeze some time to work on it a little bit each day. Time to get comfortable with it. Show
TDD for Embedded C Excellent Having the direct experience of doing TDD with guidance, rather than just reading about it, made a big difference in my understanding of it's value. Learning the fail first approach was eye opening. The exercise on Mocks was very helpful. Good balance Good balance I would like to see more discussion/advice on how to handle legacy code. I think we all have to deal with legacy code and need to know how to incorporate TDD with it. Excellent I would be interested in seeing an exercise that includes legacy code. James is an engaging instructor who made the TDD concepts much clearer for me. Much better Yes. Primarily figuring out how to use TDD with legacy code. Show
TDD for Embedded C Very Good The rational behind TDD, particularly the importance of following the steps. Make it fail first, so you know the test is doing what it's supposed to be doing. Then when you make it work, you have more confidence that you are actually testing the right thing. Good balance Good balance It might depend on where the attendees are located, but possibly shift the start time to try to have it run during normal working hours. Good The aha moment of understanding how the Mock stuff worked in the last exercise felt really good. I didn't really have that for the previous exercises, but I'm not really sure how you could add that kind of moment to those exercises. He knows his stuff, and was effective at getting his point across to us. Much better For some code yes, but a lot of my tasks are modifying legacy code. Large complex system that (mostly) works. We have a ton of so-called unit-tests, unfortunately a lot of them take a long time to run. So the quick iterations we desire for TDD are simply not possible. We also support a lot of different platforms, which also takes a long time to build. We have an automated build system, but it's not unheard of for it to take over an hour for some of our nightly builds. And code that compiles just fine on my windows box may not compile on platform-X. A lot of these are probably related to all the warnings we let stagnate in our codebase. Show
TDD for Embedded C Excellent Forward struct declarations! But as far as TDD goes, I already had some TDD background, but this class really reinforced some good habits and provided practical information around using test doubles and dealing with complex legacy systems. Good balance Good balance - Excellent - Clear explanations and a willingness to tackle specific questions/problems as they arise. Much better will try to! Complexity. Show
TDD for Embedded C Excellent The TDD workflow and mindset, and the discussion on mocks/fakes. Good balance Good balance The provided / linked 'follow on' information seems good, but as I just completed the class -- I can't speak to them. Anything more in this area -- helping get up and running after the class -- would be very helpful. Very Good I think an exercise where you work through adding tests to some 'existing legacy' code would be very helpful. James is an excellent instructor. I wasn't sure how much individual guidance and help we would get from a remotely provided training, but it was excellent. The class setup and resources were excellent to teach the material and provide relevant, hands on experience and help when needed. Much better Yes. Getting over the 'its going to take longer' hump and the (extreme) incremental growth approach in TDD. Show
TDD for Embedded C Very Good Always write test before implement new code Not enough exercises Good balance More exercieses, less presentation. Excellent More excercises! Maybe some focus/excercies on how to setup a test driven environment using cpputest or similar. Much better No. It needs to be decided by the whole team. Currently in a project "rescuing" an old product. It is decided that we shall implement automated tests for that product and start using tdd, but currently its not the most prioritized tasks. Show
TDD for Embedded C Fair Too many exercises Too much presentation Good Not at all Show
TDD for Embedded C Very Good How easy mocking is Good balance Good balance Personally, just the time difference. The course ran from 13:00 to 18:00 UK time and I had to leave early to pick my kids up, so I missed the last 45 mins on 2 days. Good Possibly splitting the exercises up into smaller chunks before feedback and then maybe covering more examples. They were quite long which meant we could have gone off in the wrong direction a while before we or the trainer realised it. He did a brilliant job. Nice amount of information, too much can swamp you over 5 hour. Much better We have just released our code so at the tight timescales bug fixing stage. Next new piece of code thought I am going to write some tests. Non really. I just needed the knowledge how. Show
TDD for Embedded C Very Good Getting experience on how to actually write the test cases and using mocks. I already know the theory but I need to actually start using it. Not enough exercises Good balance Skip the general theory about refactoring at the end. I know that it is related to TDD, but if you want to talk about refactoring describe exactly what kind of refactoring that helps you get a code design that you can test, like decoupling, dependency injection etc. Skip talking about code comments and function names etc. Talk more on how a testable code is designed. give concrete examples. Very Good Exercise 1 and 3 are he very good. Exercise 2 is both vague and to similar to exercise 1 in they way you presented it. I see the big difference is that exercise 2 is not a leaf-object and thus needs the spy. But we never wrote any of the spy-code, we got it for free. This makes exercise 2 almost the same as the first. We should have at least spend half the time improving the spy part of the code. Also the design the code of exercise 2 is vague. Change to problem that is concrete, familiar and already well known for embedded developers so we do not have to spend so much time trying to figure out what design is and how you envisioned how to solve it. Exercise 1 and 3 are excellent at this, everyone knows a linked list and how a memory mapped device works, there is no ambiguity. Good voice. Much better I would have to start with setting up a X86 compiler and make files for building the test binaries. Build system. Our code is also very monolithic. Show
TDD for Embedded C Very Good That it is not unrealistic to use TDD for embedded systems. Good balance Good balance Good Second day excercise added perhaps not so much after the first one. The concepts are interesting, though. Nice answers to questions during the course. Much better Already doing it to some extent, but to get further we need to work with these techniques with more team members. Tradition takes time to change. Show
TDD for Embedded C Very Good I was not taking small enough steps whilst I was developing using TDD. Good balance Good balance Hours were not great for me. We had to work as normal up to the start of the course at 1pm. Course is quite in depth and I was really struggling to focus by the end of the day. Very Good They seemed to be a bit complex for the time we had. Also, you could get stuck quite easily if you went down the wrong route. Time was wasted and only got so far down the exercise. Would it be possible to devise a way to re-synchronise during the exercise. i.e. Make the exercise a lot of short iterations with feedback / and continue from a correct solution after each iteration. Very experienced Much better Already started I'm finding it very difficult to introduce to team, whilst not being very experienced in TDD myself. Show
TDD for Embedded C Excellent Make your test step small, i used to chew off to much in one go. Good balance Good balance Possibly a bit more on how to bring legacy code under control. Its good for new modules, but how often do we get to do that ? Very Good Good instructor, its useful to have somebody who wrote the book, literally.:) Much better We do some, just need to progress to all. Cultural. Show
TDD for Embedded C Very Good That you write the test first, then make it fail, then do just enough to make the test pass, and that refactoring the code early in the process is very helpful. Not enough exercises Good balance Answer all the questions in the parking lot at the end of each session not the beginning. More exercises. Very Good A little more time could have been spent on the exercises, especially the Home Automation exercise. Much better To get everyone to agree that TDD is a good idea Show
TDD for Embedded C Very Good Lots of little bits of C, including bitwise operations. I expected, given exercises preconfigured to run a premeditated sequence of design-driving microtests, to get to hang out in fast-feedback land and learn effectively. I got just what I expected. I took the course as a TDD programmer wanting to learn C, fully aware that I'm not your primary target audience. I did what I needed to do to get the value I was after. For instance, during presentations, I often continued to work silently (sometimes accompanied by my pair), and when we hadn't completed the day's exercise, I worked the rest of the way through in the evening or the following morning. Given my goal in taking this course and your goals in offering it, I'm not sure what value my feedback will have to you. Please season with however many grains of salt are required. :-) Not enough exercises Too much presentation If most participants were more like me, I'd trade the presentations for more exercise time. Since most participants are probably not like me, I'm not sure what I'd trade away to get more of something else. The topic is large and three 5-hour sessions is not a long time. The exercises felt realistic enough. I very much appreciated how easy it was to get a first red test, and to have a well-designed test list to spare me from having to juggle thinking about the domain and the language. Thinking about the language was plenty! Excellent As I mentioned in discussion, I was surprised when there was global context. Coming from TDD-land, I expected (and kinda wanted) to need to do more explicit setup, and in so doing to discover the dependencies between components. It slowed me down a bit until I understood more about what was happening. It would have slowed me down considerably less had I been paying more attention to that presentation. ;-) I was particularly impressed with the timeliness and precision of help you offered during the exercises. Moderately Not yet -- haven't yet gotten CppUTest to do its thing on my dev machine. Working on it. Getting assigned to a project where we're doing embedded C development. They're not as common for us. Show
TDD for Embedded C Excellent Its hard to pin down one thing, but I think the best takeaway from this is the fact that testing embedded things shouldn't scare the heck out of me. There is no secret magic. Your simple comment of (and I'm paraphrasing) "talking to hardware is just reading and writing from memory" hit me like a gong. Good balance Too much presentation Maybe break up the presentation with exercises more? Do a small talk, then small exercise, then talk, exercise, etc. Excellent Bring it on! I already started today! Show
TDD for Embedded C Excellent Seeing you refactor the LightSceduler from single event to multi events while keeping the single event code in there until the multi events code was all in place. Don't break the code until you have something new to stand on. Not enough exercises Good balance I have read your book and also parts of other books about TDD. This means I am familiar with lots of the theory. What I really need is lots of practice including feedback. So I would have liked even more exercises. But I realize that you have to create a course that fits people with different background. Also it was good to hear the theory again of course since it was a while since I read the book. Excellent Don't know. I think they were good. No comments, was good. Much better I can start tomorrow. I guess the key is to do it step by step. We are three different sites working on the same project. Each site is in a different country. Our site has some of this stuff in place already (unit tests, automated integration tests). We still have lots of things to improve. But the other sites work with manual testing only. So each site has a different way of working but we depend on each other very much. The other sites do not care if our Jenkins server go red because the cannot even access it. We should probably fix that. Show
TDD for Embedded C Good Learning how to cleanly structure C code and apply my knowledge of TDD to writing C code. Not enough exercises Too much presentation As somebody who knows TDD and not enough about the intricacies of C, I would have the liked the sections on TDD to address more C-related pitfalls, especially when having to add tests to legacy code or balance more complex interactions. I understand that I may be in the minority of this class' target demographic (which seems to be for experienced C programmers who have not utilized TDD) Very Good A hands-on exercise involving legacy code or a more complex version of the mocking exercise would have been great. James was very knowledgable and was patient in answering everyone questions and concerns. Bring it on! I can if I am paired with somebody who knowledgable about C and I have an embedded C project to work on. Getting more embedded software projects to try this out on in the first place. Show
TDD for Embedded C Very Good Mocking C functions Good balance Too much presentation Shorter blocks of presentation/talk/code. It allows for shorter feedback loops and improves engagement. Good cyber-dojo is not my favorite development environment, but I don't have obvious better solutions. The closest I can come up with is distributing virtual box images for a linux station set up with development tools. But that doesn't get us the ability to view shared code. Possibly add a disk monitor that looks for new file updates and pushes them to a common source control repository. This seems overly complicated and error prone. Moderately I won't get to work on an embedded project tomorrow. But I will be able to apply it to upcoming personal projects. My workplace is an agile consultancy, so we're fully on board with test driven development. We are only taking baby steps in the embedded world though. Show
TDD for Embedded C Very Good The fact that the workflow of TDD adds a deeper understanding of what is a good API / Interface. Also, the ways to use mocks to simulate the hardware. Good balance Good balance If I was handed a breif description of the system behind the excercises, I would only focus on TDD. I spent some time on worrying about syntax. Very Good Information about the system. Bring it on! A huge set of legacy code and deeply embedded systems. I'm keen to give it a try in linux device drivers. Show
TDD for Embedded C Good I understood the importance of TDD but never really felt I could "sell" it to people outside of software development. Now I don't think I can code WITHOUT it which makes selling TDD exponentially easier! Good balance Good balance The course work prep could be greatly improved. Helping students/clients understand the process you'll be taking them through would make a massive improvement on absorbing the material. When we started I wasn't sure if we should be interacting with the examples while you were introducing the concepts/exercises. Since this was not in person we are able behave in ways that a more traditional setting wouldn't allow. This has benefits & draw backs. The benefits are around the ability of the presenter & audience to take what ever breaks they deem reasonable. You could take a lunch break when you knew we were all engrossed in an exercise & we could use our time as we saw fit (go to the bathroom, handle personal calls etc) without interrupting the information. That allowed us to step out when we felt comfortable. But when you were introducing the exercises I felt like I was supposed to be making modifications at the same time. Thus I was having a hard time following everything you presented. Excellent To be frank I am not sure. The exercises seem pretty solid and I wouldn't change anything here. Don't ask for a show of hands when no one is physically present. Minor issue really. Bring it on! Yes and when I didn't I felt like I was violating some moral code. Very few really. Our manager is not only excited about TDD he is backing the developers to other segments of our company. Show
TDD for Embedded C Very Good This new way of thinking, of starting "backwards"...from what I'm used to, that is. Good balance Good balance Mabye some "homework" exercises that you can tinker with outside the cyber dojo. To more set you up for the real world. There is of course the examples... Excellent The cyber dojo is a really good "classroom". The difficulty level of the exercises was good, not super easy nor too hard. You had to actually think a bit as opposed to just follow a list of instructions. But I digress...no, no need for improvement. James were good. A lot of experience... Much better I'll have to play around with the Visual studio example a bit to get the "real world" feel. Outside the cyber dojo that is. None, I guess. We want this. The more automation & TUT, the better. Show
TDD for Embedded C Excellent Specific feedback on details of my own TDD process. It's the small misconceptions that I value the most. Examples: Checking for a test failure by changing the production code and not the tests. Refactoring tests using macros to give us access to line number information. Good balance Good balance Discussion wasn't as vibrant as it could be, but I think that this is due to the medium. Very Good I'm not sure if it's good or bad to use exercises that are derived from your book. I happen to have worked through them on my own from scratch a few times, though it's been awhile since I've seen the specifics. I wonder if the over-prepared few would gather more benefit from being forced to work in a new context. Nice delivery and pace. Good job and handling the awkward silences that a remote classroom breeds. I appreciate how you were able to drop in on everyone's work. Bring it on! Yes, I've already been sneaking stuff in. This course has legitimized my exploits in TDD, so I'm hoping to use it as a springboard to implement more changes. In the worst possible case, this will definitely reinvigorate my experimentation at home. The biggest challenge that I've encountered is integrating the tests with our existing makefiles. We use a rather complex system of automakes, and it isn't easy to (or to get permission to) modify them. Still, I've been able to work around this for some of our side projects. Beyond that, it will be difficult to convince others to learn and change. You've covered all the rational reasons to change and even touched on the admission that "I write bugs", but this still doesn't instill a desire for improvement (deflate the pride?) in others. They're one step removed from the experience, and I can only hope to show them how freeing TDD is. Show
TDD for Embedded C Excellent Everything was useful if I will use TDD in the future. I thought mocks were very cool. Good balance Good balance Excellent They seems well thought out and really helped me learn. More exercises would not hurt, but we seemed to cover the major concepts off TDD and using the test harness Much better Need to reflect on these training sessions with my boss and convince him. As a consultant, unfortunately these decisions are client specific. I do believe I have to the tools to convince certain clients this is a valuable development technique. Show
TDD for Embedded C Good How to use CPPUtest Good balance Good balance Provide a better explanation of how to use the moching framwork. Very Good Provide a more guided approach. As a manager i like that you spent time explianing the emportance of starting now. Bring it on! Yes. no challenges. Show
TDD for Embedded C Very Good New development technique and unit testing Good balance Good balance Very Good Much better Show
TDD for Embedded C Very Good New development technique and unit testing Good balance Good balance Very Good Much better Show
TDD for Embedded C Good Introduction of the TDD concept and philosophy. Good balance Good balance Could have been split into 2 parts. First the introduction with small exercises to introduce the concept then allowing participants to try it on real code in their workplace then 2nd session to discuss or resolve the real life issues in implementing this in the real work environment. Fair They are very basic, but I understand why it needs to be such simple for the training. However, good use of cyber dojo Instructor is of course very knowledgeable and experienced. A little There is significant legacy code and first step is to create unit testing framework and considering significant amount of legacy code, applying it on legacy code while doing new development. - Significant amount of Legacy code and efforts required for legacy code testing. - 'Module' testing framework - All this while doing new development with again very short market driven deadlines rather than Show
TDD for Embedded C Very Good The idea of being able to have a skeleton structure in order to get going and then be able to build on top of it sounded very useful. Good balance Good balance Excellent Maybe an exercise on implementing fake framework functions. James was excellent, he gave very relevant examples that could be understood easily. The wealth of experience that he has is quite evident when delivering the course. Much better I can get going tomorrow Applying TDD for functions involving long vectors. Show
TDD for Embedded C Good Concept of testing along with development using step-by-step approach. Not enough exercises Good balance I think that for mock and fff there could be more in slides to have better understanding of the difference and utilisation; both in combination usage and standalone. Very Good I think that for mock and fff there could be more exercises. Very good and patient to listen. Moderately Yes. Most of the structure has already been in place so already have a start. Legacy code will need to be tested using the techniques of TDD and this will take not only time but also opposite thinking hat to TDD concepts as code is already there. Show
TDD for Embedded C Excellent new code testing concepts. Discovering different ways to approach code design and implementation. Understanding the benefits of close coupled test/implementation Good balance Good balance Excellent Possibly more time to allow completion of the exercises but I understand that time is limited and that there is a lot of ground to cover in a relatively short period of time. Very personable and knowledgeable on a wide variety of s/w development subjects, not just tdd Much better Sadly not... Current project is at critical pre-release stage with 3 weeks left to go - out of a 10 month development cycle (in fact, my project manager wasn't overly happy that I was on the course for a whole week...). After first release, I do plan to ensure that unit test are added to existing code and that proper tests are produced as new code is developed. Buy-in to produce test for existing code. Buy-in is already there for new implementations Show
TDD for C Very Good The core TDD approach to writing new code. Good balance Good balance On the first day - when handling the "concerns" attendees have written on the website following the initial exercise - it would be best to have a timer for yourself. Only allow yourself to spend 1-2 minutes answering each concern, before moving on to the next. You have them for 4.5 days - you can elaborate on point as you go (as indeed you do anyway quite well). Very Good Legacy code exercise. This is the weakness, or so it seems, thus far for TDD. On the face of it - there is no golden bullet (silver is not good enough). The unit testing here is conventional. But writing tests to follow the code is not always the only acceptable option. There is code that is not pure legacy. We have no yet tests - but there is knowledge in the team and ownership. I would myself consider re-justifying such code into existence by commenting it all out and applying TDDish incremental steps in developing steps until the code in back in. This will ensure FULL test case coverage. I'll try this a bit and see how it goes. I got told off for following my department wiki, rather than the instructors guide, on the legacy code day. I have to like that. Much better I started yesterday. Time. It will incrementally benefit - I know. So initial speed reduction will not have an obvious payoff to project managers. Show
TDD for Embedded C Very Good Have a methodology for testing while writing new code. Good balance Good balance Very Good Have copy of possible solution to revisit these exercises once more used to the concept of TDD. Much better Yes and already started during the workshop. Amount of potential code to be tested. Show
TDD for Embedded C Very Good Test driven development basics and details and ways to continue. Good balance Good balance Adding another example from start to end, where we don't have a ready made skeleton. Very Good I thing they are pretty fine. Instructor is nice and kind to answer all questions. Moderately Yes, definitely I got a new perspective to think about programming and apply it to my work. Because a lot of code and functionality already exists so breaking it down and reiterate through it needs some thinking. Show
TDD for Embedded C Very Good mocks and fff Not enough exercises Good balance Do exercises with FFF. In our case it would have been useful for Steve to present what our build system already had in place before we started working with legacy stuff rather than half a day later. No really your problem, but perhaps something that could be planned better up front. Excellent Nothing comes to mind. Very good. Bring it on! No, don't work weekends; next week, yes. Masses of legacy code. Need to make sufficient time available to take large complex files under test. Show
TDD for Embedded C Excellent For me the TDD aspects were very interesting and will be implemented straight away, but I found that the discussions we had about refactoring and agile sparked something in me.... I think it's called enthusiasm... Good balance Good balance Not sure... Very Good Sometimes it took me a bit of time to understand the problem being addressed because I'm not familiar with automatic light systems/X10 but that may just be old age. Very very good. Especially one-on-one. I felt very at ease discussing the state of our code. Bring it on! I will probably allocate specific times/days of the week to write tests and integrate this in to our existing code so that I ensure it gets included. Other people's expectations need to be managed. But I think we are in a position now that this should not be an issue. Show
TDD for Embedded C Very Good I have been mostly as you said from DLP world. With that your mind condition for being bit relaxed as you somehow feel that I can debug later and correct code if needed. And that's where we miss stuff. But with this TDD approach there is little scope that you can make such mistake. Of course if haven't got requirement right things can go wrong in any approach but TDD help to refine them in time rather then parking the problem for future. So I liked this thing a lot that I know what I am writing. Good balance Good balance So far in current format it seems fine to me. I am sure once we spent more time on our code, we might feel that something more could have been done. But that feedback can be passed later on. Good If it can be more of what we do then we can connect well. Ideally if a reference code is taken from our domain and then something is shown then it would be nice. James is a wonderful instructor. He is not mere instructor as he has done and experienced all things he taught in past so he can back what he says very nicely with lots of examples. And as he is from programmers world so he can connect well. He knows all pain areas and can address all concern nicely. Much better O yes. I have already started. So there is no question of tomorrow. And as we learnt that I am a programmer and I write bugs so why to wait to clean them up. I feel its more about culture. Major challenge is time but I feel that if we can apply it wherever possible and show some improvement, management would love to give more time in future. Other challenge is legacy code. With that somehow TDD philosophy is breaking and we are writing test after looking at code so its become development driven test!. so tend to bias test case writing and I am so far not comfortable. Show
TDD for Embedded C Very Good The concept of TDD itself, how to really drive the implementation from the test and how easy it is to cheat yourself doing this and therefore having some code around without being test. The refactoring techniques and were also interesting and something I will definitely use. Good balance Good balance I think that the gap between the exercises and the real word is a bit big. Maybe this is more some sort of observation that something to be improved, because starting from easy exercises is also something to have. Good The coding exercises in CodingDojo are fine, but maybe a completely blank project for the first exercise will be useful in order to mentally split what is test and what is production code, or maybe have the production code and have to create the test files by the trainee. Excellent trainer, great guy, knows his stuff. Much better Yes!, well maybe on Monday, today is Friday... We are dealing with a quite complex system and different people are in charge of application, platform... So, most probably in order to have a proper test environment, real fake functions and spies for the kernel functions and so on, it won't be easy... Show
TDD for Embedded C Very Good Developing incrementally through TDD does not necessarily take longer than develop and then test and can result in better quality. Good balance Good balance Excellent Much better Yes - but not necessarily every where. Nearly all my work is with legacy code and so I shall need to pick and choose the areas that I start applying these techniques. Vast amounts of legacy code not structured for testing in this way. Show
TDD for Embedded C Very Good 1) black box testing with white box knowledge 2) To be able to refactor and change code with confidence. Good balance Good balance For us (ie third course), as mentioned, more focus on FFF would be useful. Excellent James is well experienced, engaging and keeps his audience attentive. Bring it on! addressing the root causes for the mess we are already in! Show
TDD for Embedded C Excellent How to setup a test envronment Good balance Good balance More on setting up a test build/run environment - concepts. Overview of options. Very Good Much better Show
TDD for Embedded C Excellent Good balance Good balance Excellent Very knowledgeable and passionate about the subjec Bring it on! Show
TDD for Embedded C Very Good I used to TDD intuitively always. Good think for me is test framework - my private is evolving but no so advanced yet. Good balance Good balance Very Good Much better It's Saturday :) I hope I could - depends on Manager and project leads decisions. I hope next week they capture all those concepts. Legacy code needs enormous refactoring, decreasing number of dependencies (run time, compilation, many others dependencies) more encapsulation, less processor language, removing conditional compilation, ect. Show
TDD for Embedded C Excellent How to take a fresh look at software engineering. Lots more reading to do around this area! Not enough exercises Good balance More hands-on exercises would have been useful, although this would have required more time. Very Good Fun, light hearted approach to delivery. Course pitched at the right level to keep it interesting and to motivate us to take this forward. Bring it on! Yes. No time like the present! Schedule pressures, although I can see these could decrease as we become more proficient at this way of working, and we start to less new problems being generated, etc, etc. Show
TDD for Embedded C Very Good Incremental development and continuous integration with testing done in an agile methodology yields software with less defects. Good balance Good balance Given a fixed amount of 1 weeks time, I suppose the initial TDD ideology build up may take a little less time like 1/2 a day and start with more exercises to better illustrate the TDD concepts of CPPUTest. The exercises them self illustrate how effective TDD development can be. Just my thoughts. Good Little higher number of exercises. Very well organized training material. Good exercises chosen starting with the simple ones first and building up the contents to use more sophisticated techniques. Handled the timing of answers to some of our nasty questions very well. Much better Yes. Exercises though only a few helped get hands on to the TDD techniques. Day4 legacy code exercise gave insight into how we can apply them with a fair amount of progress. Not an expert yet but sure I can get there with some practice. Complexity of our current code. Show
TDD for C Very Good Developing the step by step approach which I can apply not only for my code but for many things outside the code Good balance Good balance For a person like me the course should take both the new code & Legacy code to take into consideration and should cover how we could have improved the Legacy code if could have done it the TDD way Good Exercises are Good and I would like to see the exercises dealing both for the new code and imagining the same code as a legacy One Resourceful with commendable practical Knowledge Moderately I can start from tomorrow but may take some time to ramp up Anticipating the Complexities of the Header file includes.. the header files are not taking care of them on their own..even after half a day I couldn't able to overcome the difficulties associated with l1_rsrc.h when i include it in my unittest.cpp file due to the interdependencies on many other header files and definitions Show
TDD for Embedded C Very Good The application of the theory to the day job (day 4). Which used the previous days to be able to make progress. Good balance Good balance the course is good, the relevance of it to the business is key to applying it. So in conjunction with something for other staff (management, business unit, support, test etc..). Adding a social event to discuss informally outside of work would be useful. Very Good The mock one could benefit from some clarification or examples to fully appreciate the new terms. clear and real examples helpful to add context to theory. Much better Yes :) project pressures and I don't believe TDD can be applied without understanding in other business functions I have yet to see. Show
TDD for Embedded C Very Good not to be frightened of applying these techniques to the reams of legacy code Good balance Good balance even though the course was for embedded C there were some C++ concepts that went over my head - maybe an extra little time for the benefit of non C++ would have helped Very Good faster link / response to cyber-dojo as our session took ages to run on each "test" fun guy who spoke sense Much better tomorrow is Saturday ....... :) ..... and I have some existing "day job" things to finish off. Also need to discuss with other team members to get a uniform approach for the same area of code management will mis-understand what they will get out of it and when as well as when pressure is on corners will be cut (again) Show
TDD for Embedded C Excellent The course showed that it is easy for us to adopt TDD and that we can achieve gains almost straight away. Good balance Good balance For me the course had the right balance Very Good Thanks James - you were instructive and engaging and open to discussion Much better We have the building blocks now and will improve with practice Not finding excuses for not doing it - we do not need management buy-in, developers should take responsibility for their own testing Show
TDD for Embedded C Excellent Procrastination Good balance Good balance I think the course is well structured and reactive. Excellent They were fine. Patient :-) Much better Whilst I have new knowledge and incentive, without buy-in at a level above my pay-grade, I will not actually get the time to invest in the required NRE of establishing the test frameworks if it conflicts with the deliverables that are expected. I don't believe that management understand what adopting these technique implies for the delivery of solutions. There would appear to be a culture of denial of ignorance and this suggests to me that there will be unrealistic expectations on deliverables. Show
TDD for Embedded C Excellent Test Driven development approach Good balance Good balance May be started by focussing on changing attitude of people involved so you don't get the usual resistence Excellent Bring it on! Around million lines of code so figuring out the areas to apply it. Ofcourse finding time for it and not forgetting about it. Show
TDD for Embedded C Excellent How to apply TDD in day-to-day code changes I do Good balance Good balance Very Good More practice on advance topics like Mocks, FFF etc Really good instructor with excellent practical knowledge and answer for all questions Much better Yes because through exercises, I've developed basic knowledge of TDD and a framework for my module Legacy code Show
TDD for Embedded C Excellent What TDD actually is, which involves small incremental changes to build something. The power of CPPUnit test and the FFF framework. Good balance Good balance Very Good Good orator and good ability to control unruly engineers. Bring it on! Management Show
TDD for Embedded C Very Good Smaller steps end up with better software Good balance Good balance Very Good Much better Management buy-in and understanding of needing to take some initial pain for long term gain Show
TDD for Embedded C Very Good Iterative test development and code development is actually useful and works! Good balance Good balance It can be a tad shortened Excellent They are good as is. He is very good and knows what he is talking about. Much better Yes, i can. Bit of time management and planning Show
TDD for Embedded C Excellent I actually liked a lot the idea of being able to test code in a few milliseconds. It means that ideally in every file-save I could know if I broke something with the few lines-changes I've just done. Also, and as pointed out, having meaningful names of the test-cases help a lot understanding what is broken. Good balance Good balance The only change I would do, would be a 1h walk-through the FFF and CPPUTEST available commands before moving to the adaptation of the corporate code. Excellent Much better I feel trained to do so. But as a big project, it will only be effective if I managed to make my colleagues to start doing it too... (this would be a too big challenge for one person). I think I'm in a good position to convince them now :) Not sure that we are going to be allowed to refactor to interfaces-implementation in order to proper unit-test the code. However, the training given taught us to "engineering-techniques" (see I was listening) to overcome some of the problems. Show
TDD for Embedded C++ Very Good Good balance Good balance Excellent Much better Show
TDD for Embedded C++ Excellent Good balance Good balance Maybe make the first 3-4 chapters of the book available to course attendees prior to the class. We were given the book, and that's how far I made it in before the workshop. Seeing some of the material beforehand helped with not feeling overwhelmed on the first day nor getting bogged down by the details of the harness. Very Good The home automation exercises weren't too difficult, especially in pairs, but they did seem to be a bit long. Also, a group review of the results could be useful, just to see how the different attendees approach the exercise, but that might be outside the scope of the class. Moderately Not yet. Quite a bit still needs to be done to incorporate TDD into our FPGA workflow. Show
TDD for Embedded C++ Excellent The examples and the experience of running through tdd examples. As a part of that I learned the following: being methodical breaking it up into very small pieces the value of just getting tests to pass by using hardcoded values, or using "incomplete, simple code" Not enough exercises Good balance I think spending a little less time on presentations and more time coding may get us more value. Discussing more ideas and patterns for breaking apart legacy code. Excellent I thought the exercises were excellent. I wish we spent more time on the light controller and finishing that up rather than the flash controller exercise which was more straightforward. I really enjoyed the class!! I'm definitely going to be implementing the practices and ideas I learned with a lot more determination and effort. Bring it on! Our environment is suitable for implementing the practices now. However we may have some issues with working with legacy code which would take a little extra upfront effort and cost to get into a test harness. Legacy code Show
TDD for Embedded C++ Excellent The walking skeleton. I have had a hard time not knowing what to add to the tests first, and the walking skeleton makes it super clear what can be done. Good balance Good balance Nothing that I can think of. Excellent Nothing. Cyberdojo is awesome! Bring it on! I think that there will be pains in making the adjustment, but from what I saw in the mobbing sessions, we have the tools we need to use TDD. Large legacy codebase means a longer adjustment time to learn how to get monster classes into test harnessing. Show
TDD for Embedded C++ Excellent The cadence of development: Write the test Fail the test Fix the code Pass the test Good balance Good balance I think you have it down. The cyberdojo stuff was VERY cool! Excellent Very well done. Engaging, personable and gentle. Very good. Bring it on! Developing new classes, yes. Putting a test harness on legacy code, not so much. Working with legacy code. Show
TDD for Embedded C++ Excellent The TDD exercises were very helpful in getting a feel for how the process works. Good balance Good balance Excellent Very knowledgeable. Good communicator. Much better Probably. Still a newbie, but willing to give it a shot. Huge legacy code base. Most new features leverage off of existing code, so much refactoring is needed before true TDD can be applied. Also, tight coupling with application frameworks makes it sometimes feel as if our code is simply an extension of the application framework. Show
TDD for Embedded C++ Very Good Walking skeleton. Much of the entry level literature on TDD involves developing single functions. I would find myself getting stuck when trying to work with multiple, new classes. Techniques for getting legacy code into a test harness. Too often I would test the new code but just give up when changing legacy code. Sorry, I couldn't pick just one thing! Good balance Good balance More time discussing design, SOLID, etc would be helpful. This might be because I was already familiar with a lot of the basics I would have also liked to get more time on the exercises - I think our team could have used the phases that show refactoring to remove if/switch statements but I don't know where we would have found the time. Very Good Personally I would have liked for the flash driver program to be in C++ but I see the value in doing the exercise in C. It stops the argument "Well yeah you can TDD in C++ but not in C" Bring it on! Yes! I was already mosly TDD'ing but now I feel like I am more equipped and have some new tools to do it 100% of the time. Legacy code: Lack of interfaces, God classes and Singletons. Culture: Some people haven't seen the light and continue to make bad design decisions slowing down the people who are trying to do the right thing. Show
TDD for Embedded C++ Excellent Getting the process down for starting with a failing test, getting it to pass, and refactoring. Good balance Good balance Maybe some examples of using SOLID to take some "bad" code, identifying the violations to SOLID, and what you need to do. May be somewhat out of scope, but it might help to internalize some of the concepts discussed during the explanation of SOLID. Excellent Much better yes I think my specific team is motivated and ready to put this to standard practice. Show
TDD for Embedded C++ Very Good Learning TDD practices through hands on exercises. Good balance Good balance Break up the very long stretches of working with legacy code. Excellent Great presentation skills and subject matter expertise. Bring it on! Well, it's Saturday tomorrow. But maybe Monday. A huge backlog of untested legacy code. Show
TDD for Embedded C++ Excellent Good balance Good balance Excellent Much better Show
TDD for Embedded C++ Very Good The concept of write the test first. Good balance Good balance Well Designed. Good Well Designed. Thank you for all your help and guidance. Moderately Yes, It will be a slow start but once I get going I should be fine. The very old legacy code we have. Show
TDD for Embedded C++ Excellent How to deal with dependency on God classes. Good balance Good balance Have an example legacy class that we will have to work with in the workshop (maybe add it to the light switch on/off problem). As we work through the unit testing, maybe people can think how they can break the legacy class apart. Excellent See above. James is very attentive and knowledgeable. Thank you for your patience and guidance. Bring it on! I am scared to take on some of the mammoths out there, but yeah at-least now I have improved my skill to hunt them down. Time! We know what needs to be done but applying it would require time and I don't know if we would always have that. Show
TDD for Embedded C++ Very Good methodology, concepts, e.g. start with testing first instead of testing developed code Good balance Good balance need more examples Very Good need more complicated case study a very down to the earth person Much better yes time consuming, not necessary to test each line of code. Show
TDD for Embedded C++ Excellent He was taking things in even smaller steps that I was going into the class. Good balance Good balance Excellent Bring it on! I've been doing things approximately this way for a while now. I saw some new things today that I want to try out. Our legacy code has lots and lots of tangled dependencies. Show
TDD for Embedded C++ Excellent The rudiments and processes of TDD. It always seemed useful but it was hard to understand without concrete examples and instruction. Good balance Good balance 1. We use Google Test as our testing framework. While the instructor was familiar with Google, the examples and exercises use CppUTest (or whatever it's called). I don't know how many other test frameworks there are out there, but it would be good if examples/exercises could be constructed using Google as well. 2. A bit more emphasis on justification for TDD would be useful. A lot of us are old and skeptical. And while I am eager to ride the TDD train, some of my coworkers are not so convinced, especially those that were not able to take the training. I'd like more ammunition to convince them. Excellent If possible, have exercises that that use the Google Test framework. Clearly very knowledgeable on the subject and a good presenter. Much better I can start, but I'm no expert. I will need some hand-holding. It's a lot to digest. It will get through eventually. I'm still not 100% clear on some of the new concepts (fakes vs. mocks vs. spies vs. stubs) and even some classic C++ concepts (interfaces vs. concrete classes). Show
TDD for Embedded C Excellent Getting the skinny on TDD in theory and practice. Good balance Good balance Very Good Knowledgable peppered with humor. And also very practical about using TDD - wasn't religious about it. Much better Tomorrow's Saturday! Probably not right away b/c marketing breathing down neck for a last minute feature to legacy code, which would 3x the effort if started with TDD. Legacy code. Too many concrete classes being passed around. Getting functional management to back up engineers when we provide estimates that include TDD ramp-up effort, unit testing, etc. Show
TDD for Embedded C Very Good In general, just getting some more exposure to the concepts of TDD helps me feel more familiar and gave me ideas of how I can approach apply TDD to my regular work. Good balance Good balance I would have love to have more time to work on the exercises. Excellent It would be great if the was an exercise on shoehorning legacy code into a test harness. Very well spoken, and clearly an expert. Moderately Yes, with the understanding that there will be some pain at first. Getting other groups we share components with to be on board. Finding a common test interface with QA group Show
TDD for Embedded C Excellent The basic TDD cycle: write a test + make it fail + make it pass. Good balance Good balance Have it on the West Coast. Very Good He has clearly been teaching for a long time, and is very good at it. I feel I got my money's worth in the course itself; it wasn't just an upsell for custom consulting work or more courses. Really knows and lives the material. Much better I'm travelling back home tomorrow... Maybe Monday! Lots of legacy code. Lots of critical real-time behavior. Show
TDD for Embedded C Very Good The exercises proved the best way to really understand the cadence of TDD. Good balance Good balance More techniques/discussions on working with legacy code. It is what we have to deal with 99% of the time. Excellent We could use a bit more time to read over the instructions before starting writing the tests. Much better I could not start tomorrow because it would take a team decision to decide on which test harness to use and how to integrate to the build framework (which is rather complex) Need to convince my scrum team (about 10 people). Need to also devise a plan for how to combine unit tests and our QA automated integration tests. Show
TDD for Embedded C Very Good Resist the desire to write code that does not have tests for it yet. It will help you develop a more useful API for your code. Good balance Good balance Good It may be helpful to have the group talk about the tests that they should develop before they write the tests themselves. In some cases the tests were outlined in the instructions but when they weren't it took me a while to decided what to test. Very knowledgable on TDD and able to describe the benefits. The experience definitely shows as he was able to provide examples of problems companies have had in the past. Moderately I think the start up cost is too expensive until I am better at writing tests and using this methodology. For now I will use it in my personal projects and online courses until I am proficient enough to introduce it into my work. Convincing everyone else. The portion of the codebase I touch is not very large. So many other developers aren't using TDD so it will be difficult to convince them all. All I can do is use TDD for myself and hope they see the benefits. Show
TDD for Embedded C Excellent Learn an effective way to develop embedded software Good balance Good balance Maybe 3 days will be better. Very Good Much better Maybe not right now. I have to educate my boss first. Nobody in our team has used TDD. It will take time to apply it. Show
TDD for Embedded C Excellent How to implement small tests to achieve more robust and maintainable code. Good balance Good balance I think a 3-day workshop where legacy code could be inspected would be more useful than the 2-day theory/intro class. Excellent A bit more introduction to mocks may have been more helpful, although I can appreciate the need to struggle through to learn effectively. James was an excellent presenter and mentor - very accessible and helpful when questions arose. Thanks for the humor! Bring it on! Yes - I have the knowledge and the desire to begin using this tool. I am one - the others in my company are set in their ways and slow to adopt new techniques. Show
TDD for Embedded C Excellent Test first. The cost is amortized very quickly. Good balance Good balance Excellent Bring it on! Yes. The plan has been to take this learning to one pilot project @ work... None. We have an understanding manager who suggested this training to begin with and with the request that we implement this on a pilot project. Show
TDD for Embedded C Excellent Refresher and review on areas that I had forgotten. Good balance Good balance Excellent The examples were great for the time available. Very good, knowledgeable, willing to answer questions. Bring it on! I will start this evening, and I'm pretty sure I'll get my hand slapped for it. Tradition Show
TDD for Embedded C Excellent Great Course, learned alot about Test Driven Development Methodology. Understood with hands-on examples that TDD can be very useful in finding defects early and can reduce the burden of testing multiple classes, units later on. James is a great teacher and speaker. Good balance Good balance Possibly talk about documentation. Excellent Flash Driver example is a bit tough to understand for a novice C developer. Plus there isn't enough to actually finish that exercise. Hope another example is substituted for it. James is a great speaker and teacher. Bring it on! Show
TDD for Embedded C Very Good techniques to testing Good balance Good balance Improve slides Good provide a reference solution well organised and relevant Much better yes time constraints Show
TDD for Embedded C Very Good The usefulness of having comprehensive tests and needing to refactor code Good balance Good balance Maybe the ability to store/zip the code dojo code we wrote for future reference. Maybe a bit more on module test after the unit tests have been created. Very Good Possibly and example of the completed version of the exercise to ensure people were on the "right path" James was good a good instructor and did well at monitoring peoples progress. With such a big group it is hard to keep up with everyone, but maybe pointing out some more classic mistakes would have been useful in changing out mindset to TDD. Moderately Yes but a lot of my code it knitted in with others so it isn't easy to just wrap a function and being testing. I have started putting in the framework for one of my modules, so I haven't given up. Being end date driven means we already drop design to have enough time to implement. Poor requirements means that creating tests is harder, they do not tend to firm up so assumptions are made. Not being able to phase functionality very well, functionality is normally in quite large chunks, we need to try and phase it better so that even if it takes longer there is always partial working functionality. Even though peer programming is a wonderful idea and everyone agrees it would be great, we are stretched to the limit already so doing this would affect our initial revenue (but probably cause less bugs long term) Show
TDD for Embedded C Excellent Writing small piece of code that can be tested Good balance Good balance Excellent Not sure whether pairing is good for doing exercises. I think each of the participant should do the exercise independently and if get stuck should seek the help from the other person in the team. Much better Yes, I am planning to use TDD in my daily work. My code base need some build related changes for doing the cpputesting. Show
TDD for Embedded C Excellent Good balance Good balance Good Bring it on! Show
TDD for Embedded C Very Good The TDD process, developing with a test framework and the connection between TDD, CI & Agile. Good balance Good balance Not sure, it was pretty good. Very Good Much better Yes, already have. Our current development process is not well aligned to this way of working. I will apply what I've learned but I suspect it would be more beneficial with a CI system and more Agile oriented workflow. Show
TDD for Embedded C Excellent Having done TDD before I was already familiar with the concepts, albeit in an object-oriented manner. The most useful thing I learned was that we can start applying these concepts, today, in our embedded C environment. I had assumed there would be more of a barrier. Not enough exercises Too much presentation Sometimes the slides felt a bit disjointed - plenty of hopping around between slides showing different and not apparently related concepts. A little more focus on refactoring would also have been useful, particularly in respect to identifying the refactoring techniques such as extract-function, extract-module, parameterise-function etc. TDD and refactoring go hand in hand in legacy code, and I'm not sure this was particularly apparent to the audience. Very Good I would have liked to have done more with mocks. They are complex and could have done with more attention, especially as they are likely to be quite heavily employed in our embedded unit tests. Extremely knowledgeable, passionate about the subject and plenty of experience applying the techniques taught in the course. A nice guy, and happy to buy a round of beers too ;-) Bring it on! Tomorrow? We are starting today! The main barrier is the cultural shift required away from deadline-driven short-termism towards longer term investment in good, tested/testable and maintainable code. The fact that our management are keen is a good sign, although it will be interesting to see how they deal with the reality of a slowdown in development pace while this is adopted. Show
TDD for C Very Good stress on creating tests first before coding Good balance Good balance For us specifically, we do code refactoring all the time, so it was a bit redundant to do the refactoring exercise and go through tens of slides, the portion on refactoring on legacy code was excellent though Instead of the third morning spent on doing refactoring exercise, i personally would have liked to understand what a mock or a fake does and do that exercise in more detail Good More Mock/fake based ,skip the one on refactoring very pleasing personality Much better Why not! legacy code Show
TDD for Embedded C Very Good That I need to try to change the way I think about all aspects of software development. Good balance Good balance Very Good Very Knowledgeable, helpful and approachable. Much better Yes It is very rare in our system to add completely new standalone code and therefore almost every new piece of code couples tightly with legacy code. Considering how long I took to create very simple tests, I worry that the close interaction with legacy code will severely complicate the creation of tests and hence will significantly extend the time taken to implement a feature. Show
TDD for C Very Good Quite lot, Major one is how to defend bugs more effectively which causes due to code modification. Good balance Good balance I would have preferred more C++, but I cant give this comment here as this was supposed to be TDD for C :). Very Good It would be nice to have bit more explanation (not about concept, but code) before each exercises as sometimes we have to go through the different files to find out what is the overall flow of the example. James is very good instructor and paid attention to each participant individually. Much better why not? I do work with C++ and need more investigation on hoe to integrate this in our very big application, which has lot of static library/DLL/COM projects. Show
TDD for Embedded C Very Good With incremental small changes, TDD can help build more solid code. Good balance Good balance Good James was helpful and ready to discuss and elaborate on our questions. Moderately Yes, but I might need more help from my peers in developping some stubs/FFF. This would work well for new code. For legacy code, I would like to improve the unittest coverage as part of a bug fix, but generally the timescales there are quite tight. Show
TDD for C++ Very Good Breaking down the code into smaller chunks can help with the structure of program as you should test on extracted areas so don't have too many dependencies Good balance Good balance I would prefer to have known how the different parts are broken down, i.e. which bits were CyberDojo, which bits were cppUTest/unit testing and which bits for specific to TDD. Very Good Exercises where there were lots of files were confusing as didn't know which files we had to change. James was very good, he explained things well and showed how the concepts can/need to fit into everyday. Bring it on! No it is Saturday but will start Monday morning. Legacy code, lots to test and having to test large complex information in and out Show
TDD for C Excellent How to use CppUTest Good balance Good balance I would have liked some discussion about tools that can enable us test concurrency. But I guess that's not within the scope of the course Excellent None. The exercises were excellent Bring it on! The approach needs to be widely adopted so that tests created are respected by other engineers Show
TDD for Embedded C Excellent Don't change the code without being pushed by a failing test. Good balance Good balance Longer. 3 days exercise was good but more follow up with legacy code would be ideal. I understand companies may be reticent to go along with a longer course though! Excellent Allowing two files to be viewed at the same time in coding dojo. Excellent Bring it on! yup Ensuring that any tests we add are run regularly and the results taken notice of. Show
TDD for Embedded C Very Good Good balance Good balance Very Good Much better Show
TDD for Embedded C++ Excellent That test driven development can make a significant contribution to code quality Good balance Good balance Good so far Excellent None Excellent tutor Much better No. Wearing a managers hat makes it difficult but plan to co-develop and pair with each team member to enable the application of this useful technique There is always something else more important or time planning to include TDD as an important part of the work Show
TDD for Embedded C Good Good balance Good balance Good Moderately Show
TDD for Embedded C++ Excellent TDD Good balance Good balance More James! Excellent More James! Awesome. Bring it on! Show
TDD for Embedded C Excellent Good balance Good balance Excellent Bring it on! Show
TDD for Embedded C++ Very Good Tests help to drive good design Good balance Good balance Excellent Much better Show
TDD for Embedded C++ Good Not enough exercises Good balance Good Moderately Show
TDD for C Very Good The most useful was incremental development with fast builds and unit tests I like the idea of itemizing the spec as the set of tests that cover every path in the code Not enough exercises Too much discussion Overview of CPPUtest structure: how the tool compiles runs the code under development Comprehensive manual of syntax Very Good Analysis of spy function before we implement one Explanation how mocks work: what calls what, how evaluation done Implementation of spy and mock with different set of arguments and different return types Working with structures and pointers Moderately I already started It takes enormous time for moderate result Show
TDD for Embedded C++ Good step by step development with testing Good balance Good balance Good A little Show
TDD for Embedded C Very Good This is one of the most useful things I've learned Good balance Good balance Very Good I think the exercises are ok but they last too much. I would've like something like a quick exercise and some explanations instead of a very large exercise. The instructor is really clear. Much better I already started Build our own framework in order to implement this concepts in our daily work. Show
TDD for Embedded C Very Good The method to apply the TDD concept is good enough to start applying it to our normal development process. Good balance Good balance Use a single language for test and the implementation. Good May be there was not enough time to accomplish the excercises or the excercises were too long, the excercises might be shorter and reach the intended concept. -- Much better Yes. The main challenge for me is to apply al the method when the time is not enough and the code should be delivered, Logistics problems... Show
TDD for Embedded C Very Good Change the mind about the way as we are used to do the work. A different approach. Good balance Good balance Maybe doing some exercises smaller Very Good I consider it good enough, maybe don't mix languages (C / C++) in the Test definition Nothing Bring it on! Yes, however, we need to prepare the environment to execute the tests It will be ideal to have an isolated environment of testing the Software Components separated. Show
TDD for Embedded C Very Good The concept that every line of code introduced has to satisfy a test. Too many exercises Good balance Good In my opinion, I got the same learning for all the 3 exercise, I would need more time to catch differences between them. I know this could be because of the narrow time we had for the training but i would prefer shorter exercises in which the differences between them could be reached faster. Moderately A lot of code is reused and a lot of modules had to be refactor Show
TDD for Embedded C Very Good mocks Good balance Good balance - Very Good - - Much better I need to automate first an environment. My idea is to be able to code in C and execute the test cases in python. So, I want to automate the generation of a DLL from a module spec, to compile it and then to execute the test cases using python. to deal with tos of legacy code. I am completing the architecture spec from it Show
TDD for Embedded C Very Good Deliberate process for writing unit tests. Good balance Good balance Reference of the TDD framework prior to start. Very Good More examples of using the framework under difference IDE's; Engaging - Good working knowledge of TDD. Moderately Yes, however first I will need to bring the framework into our development environment Time Show
TDD for Embedded C++ Excellent Lots of useful and new things learnt. 1. Importance and benefits of TDD. 2. How to incorporate TDD in our code. Good balance Good balance Course is good and balanced, and covering good stuff. But need some more time to do hands-on in front of trainer. Excellent Instructor is very good & knowledgeable. Going as per audience's pace. Making session interactive which really helps to raise and clarify most of the doubts. Bring it on! Yes. Time is always a challenge, apart from time legacy code and having dependency on third party libraries is one of the challenge. Show
TDD for Embedded C++ Very Good Framework and approach Good balance Good balance It took time to change the mindset. This is normal to i guess to most of attendees. If this can be addressed... it would be awesome.. It is challenging Excellent They are good. James is an excellent trainer, very hands on TDD and lot to learn from his sessions. Bring it on! Yes. I want to adapt this given my PO and TL are on the same page. Approval Show
TDD for Embedded C++ Excellent How to hook up the test harness to our development code. Good balance Good balance It's pretty good. Very Good Much better I will try. At the beginning, we need to budget time for the ramp up. Show
TDD for Embedded C Very Good Create test before coding Good balance Good balance Very Good Moderately Do not use C or C++ at the moment Show
TDD for Embedded C Very Good How to apply procrastination Good balance Good balance Less slides, more direct questions to the audience in order to trigger discussions Good The legacy code exercise requires some additional preparation in order to get the best out of the available hours A real expert, great communication skills Much better yes change my mind. first the test than code Show
TDD for Embedded C Excellent That there is a scientific, linear and simple way to develop code that I can trust and be confident to more than the one I use now... Good balance Good balance Maybe giving a bit more in deep on that "special techniques" used as workaround when you're facing low lever hardware-related modules... Very Good Maybe giving a bit more in deep on that "special techniques" used as workaround when you're facing low lever hardware-related modules... Very good approach with the attendees, very stimulating, nothing to blame Much better Yes, but only on a new project - Change my mind to think and develop in the "reverse" mode - Forcing me to make small steps Show
TDD for Embedded C Excellent In addition to your book I've read before: The mock usage. Seeing it used and trying by myself, it is pretty clear in minutes. Good balance Good balance - 3 days instead of 2 ;-) - Maybe to emphazize code smell and refactoring a bit more in the Training session: TDD is not only about generating code, but to write maintainable code. What is maintainable? Excellent Nothing to add. They really are perfect, very well-guided small step examples and the tool chain you offer is great fun. Not always easy to understand, but in total very impressive and helping. Bring it on! I've started yet. Time to expand the radius to legacy code. The delay of cost to benefit: The costs are effective today (learning and writing tests) and the main benefits we can earn mainly tomorrow when we see the value of good and maintainable code. For small tasks, one might think "it's not needed", for bigger tasks "it's too complicated", when the fun of TDD isn't yet present in one's DNA. In crisis mode, "make it work" is faster than "make it work, make it right, make it fast". Show
TDD for Embedded C Very Good The "small step" approach to coding looks very promising in avoiding introducing bugs, mixed with the batch of small tests could really save debugging time. Good balance Good balance The course was clear and made good example to explain more complex ideas Good I think that the exercise section might be improved. Like this is a bit slow to see the code typed in, and might get boring, since some parts are the same. He was nice and explained everything well. Bring it on! I think I can start on my next new project with the TDD approach. Seems easier to start from scratch to learn how to do this than to convert a legacy code to TDD. For sure I will try soon to use TDD to avoid forgetting the main ideas My main challenge is that the code is for embedded projects, so it's very hardware related. This might create some problems to create the right test, simulating hardware stimuli. Show
TDD for Embedded C Good Good balance Good balance May be a initial global preview of the course Good No suggestion Friendly and handsome A little As most of the case, there is too much pressure for production Gain the time to start Show
TDD for Embedded C Excellent I can use TDD to force my code to "behave" (yes, that's repeated) Good balance Good balance Really hard to tell. I've never attended a better course... Very Good Coding dojo had many timeouts on day two. While I liked this tool very much, this was annoying. Maybe if there was an offline-tool this could be avoided. Very likeable, very attentive and helpfull. Bring it on! I can start tomorrow, but mostly because of the workshop. Of course the training was preparing this, but without the workshop it would be much harder. Remembering how all this stuff workes until it is routine Show
TDD for Embedded C Excellent To develop by incremental iterative small steps: red, green, refactor. Good balance Good balance Excellent Instructor was clear in explaning concepts and showed high professional competence on the subjects. Much better Yes. I have the basic knowledge to setup a working environemnt for TDD; I know what's the goal of the process. The major challenge is to change my mindset; after that I need to try and prove myself that the technique will improve my software quality and development speed. Show
TDD for Embedded C Excellent Slow vs. Fast reaction is a winning strategy. Good balance Good balance Excellent Provide in advance the exercise context. By example tell us that will wil goes to implement a scheduler or led driver or something else. James you're great. Professional. Passion and good sense of humor. Much better Yes, I can. It's a matter to change my mind. Show
TDD for Embedded C Good The benefit of TDD. Good balance Good balance Very Good Much better With the given Information i am able to start immediately Nothing, i just have to get used to it. Show
TDD for Embedded C Very Good Seeing how TDD helps bring Agile approach + unit testing together to make sure have confidence in what's developed works / doesn't break existing functionality, removes need for manual testing at this part of the lifecycle. Too many exercises Good balance Very Good Clear in describing problems and solutions, obviously knowledgeable in this area with plenty of real-world experience. Bring it on! Maybe - need whole team to commit to following this approach. Whether it's still seen as an extra overhead by others in the team. Doing this consistently, not skipping it just because of time constraints. Possibly need buy-in from project management so they understand the timescales quoted. Show
TDD for Embedded C Very Good 1. To start, just "write a test"! 2. Don't write any code unless its to fix a failing test Good balance Good balance I thought the balance between theory, background and the exercises was just right. Can't think of anything to be changed. Very Good I thought they provided a good introduction to the problem space. I liked the use of the Cyber-dojo to provide a pre-tested build/execution environment and multi-person working. Very good, patient and willing to discuss 'the why' and well as 'the how'. Obviously understands the problems and the solutions, and where to go look if he doesn't. Much better We're currently in a 'definition' phase (requirements capture and review), but this will generate work-packages for implementation. The intention will be to use TDD to develop the code and tests for these packages as a learning exercise, then integrate into our Jenkins regression environment. Getting buy-in from other members of the team that haven't received the training. Integrating it into our development process and understanding impact on 'velocity' Estimating how long it will take for others to understand and use TDD effectively, and mitigating against management expectation on team velocity. Show
TDD for Embedded C Excellent That software can be developed in a different ways and sometimes we are too set in our ways to think about better methods Good balance Good balance I can't think of anything major that could improve this course. Excellent I found the exercises useful and they were at the right level (not too easy, not too hard). James is very knowledgeable and passionate about TDD and gets his points across very well. He keeps the course flowing and makes it interesting and enjoyable. Much better I would like to start tomorrow but it needs to be a team decision and we need to put things in place to make it easy for everybody to use. Convincing the management that this is the way to develop software for our next project, and managing the expectations about how quickly it will provide benefits. Show
TDD for Embedded C Very Good The new approach and test methodology. Good balance Good balance I don't now. Very Good I don't now. Much better My project is very complicated. Before of start of test is necessary resolve the conflict of the files The time increase necessary to develop the module. Often we have limited time. Show
TDD for Embedded C Very Good the production code organization is very important for its maintenance and I learn that the code refactoring is a good practice Good balance Good balance the days of course should be increased Good the extra time for a real problem in my work should be considered he is a good teacher and he is an expert of this argument A little I cannot start bacause the Legacy code contains dependencies that we have to resolve. We need to much time to resolve this issue before appling this approch. Perhaps my manager could not agree Inject to my team the importance to introduce this approach Show
TDD for Embedded C Very Good clear and rapid feedback to the developers as they are writing code. Step-by-step methodology used to solve complex problem starting from simple Good balance Good balance with code challenging, this forces peoples to have a much more attentions during theory speaking Very Good Having a frame inside the the Code-Dojo page with some tips and tricks for the exercise Much better I like TDD approach, but I'm little worry about our project deadline Have a legacy codebase in order to better isolate module development and header inclusion Show
TDD for Embedded C Very Good TDD is a new concept and eye-opener to me. It is good to start from real examples. Your course material with test case examples are good guide to steer new starters to the right direction and grasp the TDD ideas. If we have a new project, I will be very willing to apply TDD ideas to start with. Good balance Good balance Excellent Much better Yes, I would like to. However, as our project is in the middle and late stage, it may be difficult to fit in. We have other ways to test code already. We may not have time to test all units and functions in a new way. The main obstacles are time scale and resources. There are different groups of engineers in different countries in the project. Show
TDD for Embedded C Excellent VERY small steps during the write-test fail, code, test pass cycle Exploding Mocks. Difference between mock (expectations) and stub/fake. Good balance Good balance Excellent I can't think of any obvious improvement.The Dojo exercises are very good. And the method of James' tidying up each step and we all re-start from the same place each time. Prevents people getting further and further behind. Also James' monitoring of our progress remotely and then targetting people to help them is excellent. Very good. Concise, experienced enthusiastic professional engineer who knows the world we work in, and who is very good at getting new concepts across. Also a fun personable guy! Much better Yes! Buy-in from management. Technically we can do it, and I am convinced we should. I think we may move slowly towards this method - possibly to go hand in hand with Agile, if we could adopt that. That hurdle is the biggest to climb since requirements capture is a big issue for us. Show
TDD for C Very Good I believe the effort of developing small tests in parallel with design helps creating better testing. Also it may give you time to think twice before coding. Good balance Good balance The only thing I would add is a real scenario so we have the feel of how many test are necessary. Very Good Not necessary in my opinion He was clear and his explanations were really good and inspirational Much better Already started during the course and planning to continue using it. The challenges is to maintain the rush for coding everything and take smaller steps (after the test if written first) Show
TDD for Embedded C Very Good the development approach: - identify all dependencies and modularize well the system - refactoring the code for encourage the maintenance Good balance Good balance is good as it is Very Good may be with a better development environment His preparation fit well with the topics of this course Moderately Too much legacy code to clean up clean up the legacy code and make refactoring Show
TDD for Embedded C Excellent Slow is the new fast; the "Why" of TDD as opposed to the "How" or its "Goal" Good balance Good balance Providing test projects for Visual Studio and Eclipse Excellent Great evangelist Much better Show
TDD for Embedded C Excellent a completely new way to approach writing code Good balance Good balance Very Good very excellent and expert teacher Much better on Monday we can start cleaning up code trying to remove usefulness dependencies Show
TDD for Embedded C Very Good The TDD mindset of writing tests first and only writing code necessary for each test to pass Good balance Good balance The examples took a lot of time for the course only being two days long. Would have liked to go through the presentation/book more and had quicker examples Good See note in "How can this course be improved?" Much better Would like to start tomorrow... still battling timing with delivery date and working mostly on existing code. Working with existing code and going back and correcting all of the dependencies Show
TDD for Embedded C Excellent I became much more proficient with the CppUnit tool, greatly enjoyed using Cyber-Dojo, picked up some very good ideas on using unit tests to self document the task level of user stories, and benefitted from all of the classroom instruction and interaction. Good balance Good balance Have students do some background reading before the class. Excellent Change pairings more frequently. The instructor was better than excellent! I learned a lot in class and left excited to do more. Bring it on! I have already started working with our teams to implement TDD and ATDD. Am trying to employ some of the knowledge gained in this class to enhance/improve our processes. We have a lot of advanced beginners who think they know more than they do and resist change/new ways of working. Show
TDD for Embedded C Good Good balance Good balance More real world examples on real embedded systems Good A little Show
TDD for Embedded C Very Good Unit testing is requirement thorough the development cycle Good balance Too much discussion 1st day the content was very light. The discussion on the 'survey' and the 'sticky notes' provided me very little value. Without those the material was about 4 hrs for a full day of training. I expected 8 hrs of training (8:30-5:00 with 30 minute lunch) Very Good More complexity. Not a standalone module but something from a more complex legacy embedded system. Kept me engaged. Consider how to bend the rigidity of TDD to fit customer needs. TDD is a method. Can it be decoupled from CppUTest. Much better No. I/we don't introduce many 'new' modules so this needs to be applied to legacy code, and the investment in TDD on legacy code is too much. investment in TDD on legacy code is too much Show
TDD for Embedded C Good Test legacy code using test doubles, spy and mock etc to simulate. Good balance Good balance Spent too much time talking about the survey in the first day, if we need to do it, I think they should be done at the end of the training. It is too early to talk about the survey questions before we fully understand what the training is all about. Excellent I think the exercises are excellent. I think talking about the survey, the first impression of concern and surprise etc wasted too much time on the first day. Moderately The testing ideas can be applied more easily, e.g. using more simulation in embedded testing. It takes much more time to do TDD than DLP for most features that are not too complicated like circular buffer, I don't think boss will appreciate it at all. Show
TDD for Embedded C Excellent TDD Good balance Good balance Excellent Bring it on! Show
TDD for C++ Very Good The ground up approach of writing a test, getting it to compile, then getting it to pass Too many exercises Good balance No input... Very Good The first exercise was interesting (circular buffer) but the follow up was sort of beating a dead horse as they say without introducing anything new. However, the third exercise which introduced cpputest mocking was interesting again. A very patient person. Much better yes The legacy code is very resistant to being unit tested without refactoring first. Show
TDD for Embedded C Excellent TDD will work for us. Good balance Good balance Perhaps tailor the course a bit more to our organization and the participants. (I realize this might could be difficult). Excellent Explain up front before the LightController lesson that there is some magic going on with the Makefile (link-time substitution) in order to make the LightControllerSpy work, and then explain exactly how it works after the coding session. James is very knowledgeable and experienced. He handled the diversity of personalities on our team very well. Bring it on! Yes. In fact, I can start today. I started applying the concepts on the very first line of code that I wrote after the course. The analysis paralysis aspect of our culture. Fear of the unfamiliar that keeps people stuck in their ways. Show
TDD for Embedded C Excellent The exercise we did bringing some legacy production code into the test harness was most enlightening for me. I will certainly use that approach. The concept of using this technique to keep testing needs in step with development, not rising. Good balance Good balance I thought the course was excellent. I liked the amount of participation we had doing the exercises and the round robin on the last day kept everyone on the edge of their seat and involved in wrestling the legacy code into the test harness. I liked swapping pairs too. Kept the experience moving rather than getting stale. Excellent I thought they were just right. Just right. Knowledgeable and accessible, not stuffy. Bring it on! Yes and I plan to. The amount of tangled up legacy code we have means that each exercise may be painful up front. Show
TDD for Embedded C Very Good A lot of my most frustrating bugs involve problems with synchronization between threads. You confirmed that TDD is not well suited for these problems. I think it is useful to know I shouldn't spend too much time trying to make these behaviors fit into unit tests. Good balance Good balance I still don't feel like I know how to deal with unit testing of monolithic functions before refactoring them to smaller units. Fair I feel like something more interesting than a circular buffer would have been better. I still feel like doing something that I am so familiar with would be easier and faster without TDD, even with writing unit tests. Much better A lot of the nasty, legacy code and graphics intensive code I deal with still feels like a huge (and time consuming) challenge to deal with. Show
TDD for C Excellent Establishing a discipline of making the smallest possible incremental change, and keeping refactoring in the loop. Good balance Good balance Longer time w/ fuller coverage of refactoring. That was our fault, really, since we were fitting ourselves into a schedule gap. Excellent nothing, really Good balance on letting students find their own answers vs. guiding in the right direction. Bring it on! YES! Deciding to do it, in spite of the well-established muscle memory in bad patterns. Show
TDD for Embedded C Very Good Dealing with legacy code and brining it into the test harness. Good balance Good balance The only real hitch for me was the first day when we where practising TDD in new development. The incimental steps where so small that I wasn't able to see the end product via the steps. Good I honestly can't think of anything. I think we could have gotten to refactoring existing code at about the halfway mark of the second day. Much better Yes. I can easily target a single area of my codebase and beging brining it into a test harness. Getting everyone on board with the new development process. Show
TDD for Embedded C Excellent Practical experience with CppUTest best practices. Good balance Good balance Excellent Bring it on! Characterizing before refactoring. Show
TDD for Embedded C Excellent How to avoid writing inefficient and confusing code, make the code more readable Good balance Good balance Very Good Much better Not quite. I still need to figure out something in our framework before starting trying this properly. I think we might need to invest more time in the beginning but it should be beneficial later on for code development. It is a bit difficult to test live audio streams which is what our DSP processor is mainly useful. I need to think it through before applying for it. Show
TDD for Embedded C Very Good Good balance Good balance Very Good Moderately Already used some TDD to write new code with unit tests. Haven't worked with legacy code yet. Legacy code and its maintenance makes it more difficult to incorporate the new ideas. Show
TDD for Embedded C Excellent Making small steps really works. Good balance Good balance If I could do git clone, use my own text editor instead of web based one, and then git push my changes, that would improve experience, for me at least. Excellent Hard to say, it was all right. Much better I could if would do coding, but for next couple of weeks I'm not planing to. Significant chunks of legacy code, where bringing it into test will take several days, I guess. Other one is just a human factor, to actually start doing it. Show
TDD for Embedded C Very Good an understanding of the concept of TDD, the benefits that this way of developing software may bring Good balance Good balance nothing springs to mind, pretty well balanced course, from an attendee point of view though i think it would have been beneficial for attendees to have been exposed to their companies approach to TDD tools and practises before attending the course, some of us were and some weren't. Excellent not requried very good knowledge of the subject, excellent presentation skills, friendly chap. Moderately unlikely, the department is undergoing an attempt at a significant change of the way software is developed under the leadership of a new manager, the TDD approach is not yet adopted by any other parts of the company and as such is unlikely to be given significant backing at this time and is further hampered by the need to keep producing releases of products to satisfy marketing etc, even worse is the fact the company has just been taken over and demands for departments to hit their delivery targets is even higher than it was before with the threat of a massive restructuring looming ever closer. the need to deliver products means it is just not feasible for everyone to stop producing stuff to learn a new development technique, whilst it would help longer term there is a strong possibility that there will be no 'longer term' if releases are not maintained in which case it would all have been in vain. Suggest a few of the team adopt this new way of working and gradually move over to such a way of working to not totally destroy current production rates, there would then be a number of very experienced people that could bring the remaining team members up to speed much faster, but hey, what do i know..... Show
TDD for Embedded C Very Good I was developing code and then writing unit tests. So it was always a last day and least priority task of writing unity tests. Now I could understand the method of developing unity tests along with implementation. Good balance Good balance Good Much better -Time line -Legacy code is so much coupled, less re-factored and difficult to understand, so writing unity test on this is a challenge. Show
TDD for Embedded C Very Good How to start writing new code in very small steps Good balance Good balance I think it's already OK Very Good Much better I could if my work would be to add a new feature Show
TDD for Embedded C Excellent - Helpful when developing new functionality independent of hardware, tools and environment in place, thereby parallel development is encouraged. - The test scripts serves as Documentation and API usage as well. - Refactoring the reiteration of tests continuously helps improve code quality and makes hardening phase easier. Good balance Good balance Excellent Instructor is excellent well versed with the topics and very helpful in answering queries. Much better yes why not. legacy code is risky to refactor though it isn't TDD issue its probably the risk of having to change code which is been there for long. However improvements to this code can still be helpful if we follow tdd method. Show
TDD for Embedded C Very Good How to do TDD. Good balance Good balance Good The Spy exercise contains many more files than necessary which was confusing at first. Bring it on! At home yes. At work non-technical elements stand in the way. Cannot gain permission to install and use an off the shelf unit test framework. Show
TDD for Embedded C Very Good Being much more conscious of the single responsibility principle for the software modules and the interactions among them while writing the code in order to avoid spaghetti code for the future. Good balance Good balance I'd suggest that the trainer sits down with the pairs more closely who were not performing quite well with the exercises. I'd also suggest that when the trainer has a good idea about the individual's performance after the first couple of pair programming exercise, trainer matches the pairs for the following exercises more efficiently depending on their individual performance. Good Instead of enforcing 1 exercise per discussion topic or subject, there might be 1 or 2 more options which the attendees would agree and choose to work on. Sometimes, a certain example would make much more sense than the other depending on the engineers' past experience. He is kind and professional. He knows the challenges we have in the industry very well. He is truly an expert on the subject of TDD in embedded C. Much better For the new code, it sounds completely feasible and we will and must do it. For the existing code, we can't afford it for the majority of the cases as we are in bug fixing process already and are fast approaching to the project deadline. I personally believe I need some confidence in TDD before refactoring the legacy production code properly. Time-wise, the way we start writing software and converting the legacy code should be communicated to the stakeholders very well to avoid short-term disappointments. Show
TDD for Embedded C Very Good The concept and process of TDD Good balance Good balance Although it was interesting to hear about other groups code practices it may make sense to concentrate on single group areas so everyone is familiar with the software and processes. Good Friendly and engaging. He was very knowledgeable and I found myself agreeing with many of his comments on code practices. Moderately No! tomorrow is Saturday :-) The initial learning curve Show
TDD for Embedded C Excellent TDD is basically a "way of life". Although there are some resistances to starting using it, at the end it makes coding much more comfortable when you start from scratch. The hardest will be how to make a legacy code to work, especially legacy code with heavy dependencies. Good balance Good balance Not sure how. I think the course can be improved using new examples and coding situations. That means this course should be taken from time to time in a way to share experiences. This is actually a suggestion for improvement as a whole (course and attendees), not only the course itself. Excellent In the same way the course can me improved. Thanks for the training. Much better Yes I could, if the work assignment allows (at the moment I have bug-fix, but I'm very keen to start applying TDD as soon as possible). code refactoring Show
TDD for Embedded C Excellent Tests are not difficult to write TDD helps ensure well thought our production code TDD is certainly the way to go moving forward Good balance Good balance N/A Excellent A better editor would have been good Both James and Mike have a fantastic style about them, they present in a well, clear, mythodical fashion. They encourage discussion and rather than tailor problems to simple examples, they actually try their very best to take the candidates codebase and taylor their answers to that. Bring it on! I believe I can, I feel I have the confidence to present to colleagues and using the examples that were used, I feel that I can bring them on board. Getting the buy in from upper management, however things have to change as we can't go on the way we are! Show
TDD for Embedded C Excellent Writing the test first is easier and ultimately faster than coding the test afterwards Good balance Good balance Very Good Knows his stuff and is enthusiastic about explaining it Much better Yes (well, Monday). My boss understands the benefits Very large base of existing, untested code Show
TDD for Embedded C Very Good Got sufficiently motivated to be apply to TDD in all the future production code I write and convince others as well to use this technique. Good balance Good balance Very Good Much better The company doesn't seems to have enough resources to invest time bringing the legacy code into the testing framework just now, but definitely something to be considered in future at the earliest opportunity Show
TDD for Embedded C Excellent That it's not an impossible task! Good balance Good balance Excellent Great presenting style! Having Mike worked really well too. Much better Yes! Legacy code! There isn't a plate big enough to hold our spaghetti, it's going to take a long time to get our code into test harnesses. Show
TDD for Embedded C Excellent How to write new TDD test starting with a blank sheet of paper. Starting something new is always the most difficult step. Good balance Good balance Very Good Engaging, shows a genuine enthusiasm for the subject matter. Makes the concepts involved easy to understand Much better Will try to apply these methods next week. None - we have buy in from management Show
TDD for Embedded C Excellent TDD development workflow. Confidence to go and do it Good balance Good balance Very Good Very good presentation, engaging. Much better probably not! Current project deadlines (a matter of weeks) would not allow. Would push for it in the next iteration Getting time allowed for the initial work to be done balanced against project deadlines. Show
TDD for Embedded C Excellent The philosophy and the mindset behind TDD Good balance Good balance I've got no suggestions. It was very good. Excellent James is a very good instructor balancing concepts with worked examples Bring it on! No it's Saturday tomorrow :) Getting started whilst maintaining expected output in the short term. Show
TDD for Embedded C Very Good Writing detailed tests can help you understand what your code does. Not enough exercises Good balance Excellent More time to work more on the exercises. He's very good. Much better Tomorrow is Saturday! More seriously, I have very pressing tings to deal with, but I think that those of us who attended will continue to work on the start that we made, and will present some ideas to our colleagues soon, in hopes of at least getting more unit testing done. Perhaps TDD could follow at some point. Getting time from managers. Show
TDD for Embedded C Very Good General concepts of TDD. I use assembler on a proprietary DSP, so some of the details weren't directly applicable to me, but we were able to create a simple test harness for our DSP by the end of the workshop Good balance Good balance some of the slides were flicked to a little quickly or skipped entirely. Don't assume people know all the acronyms that you use. Good knowledgeable and good communicator Much better Show
TDD for Embedded C Very Good Some of the rules and guidelines for successful refactoring. If I hadn't worked with a Unit Test Framework before, it would have undoubtedly been exposure to that. Good balance Too much discussion Whilst the discussion was good for keeping engagement of the listener, I felt that sometimes we restated things a little too much - I recognise this is subjective though, but for my needs I think we could have spent more time exploring new ground... Excellent Much better Yes - I am inclined to use TDD extensively in refactorings I wish to make to the codebase. Getting time to pursue quality improvement, away from the demands of crisis management Show
TDD for Embedded C Very Good The process of writing small chunks of code and testing it. I was never told that since switching over to writing code a year ago. I have been writing the entire test and then trying to debug it. Good balance Good balance Good The exercises were very difficult for me because I am not a C programmer. Much better I will be better at writing code in my application. Not necessarily using your exact techniques. Everything is schedule driven. Time will not be allowed on the front end in order to get the benefits on the back end. Show
TDD for Embedded C Excellent How to use CppuTest framework, going through the process of setting up a unit test with CppuTest with a module from one of our code bases (worked after only ~3.5 hrs -- I wasn't sure we would be able to get it working in the 4 hr time period that we had available) Good balance Good balance Overall, I thought the course was well done. The only improvements that I can think of would be go into more detail on how to detail with some of the deeper points embedded developers bring up sooner in the course. I don't think we really got good insight into how to deal with this until the 3rd day when we tried using one of our code modules. Good See comment on how the course can be improved Very good. Did a good job describing the process as well as maintaining a pragmatic approach. I think this was important to keep the interest of the developers Much better yes Key challenge will be getting this started and staying the course Show
TDD for Embedded C Very Good General concepts Good balance Good balance Very Good were good Exercises were relatively simple, but all/more than were possible in the available time Moderately No, my expertise is in custom assembly and there is no "test harness" to test anything with. It is all "legacy" code by now, so only minor mods are being done. But if was started from scratch, may could have implemented some stuff within the custom tools. Just getting into C, so I am still struggling with C, so most of this went over my head, but at least I have seen it now. If someone else gets stuff setup, I could potentially use it. see above Show
TDD for Embedded C Very Good Getting a test harness around existing code so we can test off the target system. Good balance Good balance Very Good Some confusion with the mocks - didn't realize that calls to the expected read function would cause the specified return values to get queued up and returned one by one on each read. Sometimes the starting point was not clear - there were some notes in 'instructions' and other notes in the cpp file. Personable, friendly, knowledgeable. Obviously believes in what is being taught. Thought he did a good job explaining concepts. Much better I think I could. I would probably like to start with some new code and practice before going back and getting existing code to run off the target. A lot of dependencies even in fairly new project code as old stuff was copied across and things such as the redefined uintx_t's will slow things down until fixed. Show
TDD for Embedded C Good TDD can improve code quality but requires commitment to see its effects. Good balance Good balance Good For circular buffer exercise, add test case for explicitly checking wrapping condition James was an effective speaker and was open to listening to our concerns. Much better Show
TDD for Embedded C Excellent Being able to see how testing can be done in conjunction with developing code. This has the potential to take out a lot of the oops that gets injected from changing 1 line of code that affects other areas that are not changed. Also with TDD, there are less testing holes for bugs to escape. Good balance Good balance Excellent Excellent ability to shift the program on the fly. Good presentation plan. Bring it on! Yes. The concepts can also be applied to test code. It does validate some of the concepts similar to TDD, but to test code. Buy in from the developers. Show
TDD for Embedded C Good TDD and its application to the development process Not enough exercises Too much discussion More hands on exercises with real life code Good Taken out of real content Very knowledgeable about the TDD. Good communicator. Respectful. A little No Time that it may take to adapt to new development practice. Show
TDD for Embedded C Excellent Learning the useful ways to utilize tdd in our work environment, and how it can be useful in day to day work. Good balance Good balance N/a Excellent N/a Great Job! Keep up the good work! Much better Possibly, It might take some time to figure out how to test my module, but I'm sure it will come around. Might be tough to get started without step by step instructions, but is still possible. Show
TDD for Embedded C Very Good Learning to fake or simulate dependencies that are either not implemented yet or that we aren't testing at this time. Not enough exercises Good balance it would be interesting to see an example system you have tested in the past using only TDD to see more of an end goal Excellent I think the exercises were great, just needed a bit more of them Very personal and knowledgeable on the topic Much better Yes, the only thing I would just need to set up a new test framework first (not crazy about the cpputest). tons of legacy code is imported into each new project, so it will be a lot of overhead getting this technique started. Show
TDD for Embedded C Good How to develop embedded code on target and off target using TDD. It was good to learn that the tests do not need to be included in the production code - this was my misconception. Good balance Good balance There should be more embedded examples in the cyber-dojo exercises dealing peripherals Good Friendly and approachable Moderately Lots of legacy code Show
TDD for Embedded C Excellent planning for testing is important Good balance Good balance Excellent shorten coding sessions, discussion in between Much better requires review. improving separation between testable units Show
TDD for Embedded C Very Good Linker Substitution. Never really used it before, so it got me to try it out. Too many exercises Good balance Spending more time on the actual companies code problems. The examples are great, but a little redundant. I would have shorted Day 2 on the lighting module, gone over the concepts, and focused on the actual code as an example. Brings more real world importance to the audience, and they are likely to pay more attention then. Overall, nice job though! Very Good Thanks! A little Was already familiar with TDD. Got to see another unittest tool, which I liked, so that was a plus. Time and module dependency is more than desirable in most of our code at the moment. Show
TDD for Embedded C Very Good Use TDD and do everything in small steps. Code refactoring is very important. Good balance Good balance Very Good Moderately Show
TDD for Embedded C++ Very Good Why TDD is important. Thing is, I think it can only be done through exercises and the instructor pointing out (as he did) the mistakes people made from one iteration to the next. Good balance Good balance Not sure, but I'm thinking a 1 day course for senior programmers that already understand refactoring, decoupling, etc. could have maybe 1/3 discussion and 2/3 exercises might be good. That way more people will take the course. For this course, no explanation of C or C++ (malloc, inheritance, etc.). Just TDD. Excellent cyber-dojo.org is excellent for teaching these courses. Very impressed. The exercises don't need improvement. James was very good. Kept the class on point and focused. A little more humor might help, but tough to do right. Bring it on! Because today is tomorrow and I'm starting today. :) Cultural. I think my management is behind this and I can champion it effectively with a little persistence and determination. Show
TDD for Embedded C Excellent test frequently when you code. Good balance Good balance Understand industry of the students. Let them understand each other' project if they are from different projects. Excellent Great, nothing I can see to improve. Inspiring. Much better No, it'll be weekend. Next Monday of course. Common trunk used by two different sites. Show
TDD for Embedded C++ Very Good How to mock a function Too many exercises Good balance Fair A little Show
TDD for Embedded C Excellent Knowing the concept of TDD, and know how to use CPPUTEST. Good balance Good balance I recommend to have the training outside of the company office so we can really focus. Otherwise we always interrupt with "high priority tasks"... Excellent Much better I'll do it when i write new code. Test legacy code. Show
TDD for Embedded C Very Good Good balance Good balance Very Good Bring it on! Yes, it will help to improve the code. Convince some lazy guys to follow. Show
TDD for Embedded C Excellent know new idea to do software developement Good balance Good balance n/a Excellent very good Much better new idea for the organization, new method to develop the software. Show
TDD for Embedded C Very Good the concept of TDD and how it step by step to use it. Good balance Good balance it is good Very Good it is good good and nice Moderately some of the problem is legacy work issue, need to do it step by step. legacy code already been in a mess, which is a little hard to change at this moment. Show
TDD for Embedded C++ Excellent Somehow I had earlier impression that all tests has to be written before implementation, but you showed that it can be done in parallel. Didn't thought of that before. That same small thing kept me not practising it, because it sounded not practical in many ways. Like what if interface and business logic changes during implementation, then you'll have to go through all tests and see where you need to apply the change.. Good balance Good balance Maybe if you could prepare exercises from company work domain, something that people work on currently. But this would require that all class is from same company and working on same project. :) Excellent Its not this course topic, but still I tried to install and use CppUTest and appeared that it wasn't that easy since appears there are no manual. So maybe that part.. Great guy, very professional.. Much better Not yet, have to find new job and then start.. For a moment the part where one has to write tests and implementation in parallel. I just can't see how it ends, I'll need to try out till the end. And from practical perspective, couldn't set-up CppUTest environment easily. Show
TDD for Embedded C++ Very Good Hands on practice with CppUTest and Test Doubles (use of Mock). This was my first experience with a mock object. Good balance Good balance Be sure to keep all the practical exercises Very Good Very focused and nice sense of humor. Much better Yes, I can start right away. First step is to get the framework installed. My workhorse for development is a native linux desktop host. Agreement among my colleagues to start using TDD. Show
TDD for Embedded C++ Excellent How to implement TDD, and the benefits of it. How cpputest works. Good balance Good balance The 2 days course has a lof of info, som more frequently brakes should be alowed. Very Good Much better Show
TDD for Embedded C Excellent Hardware mocking Good balance Good balance A few more breaks would be fine. It's a bit much for two days, but then again we probably need all of it. Very Good Did not have much understanding of mocks before starting the excercise, which limited the progress Much better Yes. Integrating test regime into an IDE for a specific platform might be a bit of a challenge. Show
TDD for Embedded C Excellent using a mocking framework Good balance Too much presentation larger variety of cases (different types of interfaces and test doubles) Excellent Much better yes none Show
TDD for Embedded C Very Good Good balance Good balance Very Good Much better Show
TDD for Embedded C Excellent Very good refresh on why TDD makes so much sense. Many helpful tips for keeping test cases readable. Had not looked at CppUTest before Good balance Good balance No good suggestions - except of course that there is more topics than the time allowed Excellent Very good. Knowledgeable and intersting. Bring it on! Yes. Show
TDD for C++ Good Procedyre of implementation. Test, code crash, test works, code ...etc. Good balance Good balance Better sync between computers Very Good Much better Time Show
TDD for Embedded C++ Very Good Got feedback that my current TDD skills need a lot to improve (f.e. I tend to rush ahead with production code too much, i have not used test list etc.) Good balance Good balance I expect to hear more about techniques to do testing close to hardware (how to do mocking for hardware drivers, how to do unit testing with IDEs meant for embedded programming (Atollic Truestudio, IAR workbench, uVision etc.). Did not understand that the course is specifically for embedded, it did not feel different from TDD for C/C++. Very Good The code was missing highlighting. Felt like programming with Notepad. Good to listen a person who knows what he is talking about. :) Much better Started to use test list. Next thing is to push swapping cppunit. The whole build system (server) is cppunit oriented. Show
TDD for Embedded C Excellent The fun of pair programming and the ease of using mocks Good balance Good balance Excellent Much better With TDD no (not currently in feature development phase), with adding unit tests, making the tests more readable and improving the design, yes Show
TDD for Embedded C Excellent Good balance Good balance Good Clearly knows what he is talking about. Much better I could start tomorrow, but I would have a lot lines not covered by test's as I mostly work with legacy code. We use unit testing framework, but not in test DRIVEN way. Mindset that it is okay if the project doesn't even compile right. Show
TDD for Embedded C Very Good How TDD can reduce the bug fixing time Good balance Good balance One thing that bothered me a little was that the examples and exercises, that we saw and did, were quite small. I would have liked to see how does TDD stand up when the final source code file is above 300 lines of code. This is still a quite small file, but 3x bigger than we saw from the exercises. I noticed that the code to test lines where 1:3, one line of code vs 3 lines of test, so I would have liked to see how the test would have ended up when we have that big files. How manageable, changeable etc, would it be. Very Good Noted in the "How can this course be improved?" question The instructor was very good in presenting the material, he was very fluent and nice to listen too. Much better I could start tomorrow, but it would be very difficult. The project I am working in is in late state, so not so much implementations, but rather bug fixing. I could just take some simple file and start applying test to excisting files. I think the major challange is that not many people know/do this, so there might be some conflicts between ideas and how stuff should be done. Show
TDD for Embedded C++ Excellent Creating test doubles Good balance Good balance There could be more examples about creating test doubles for legacy code Very Good There could be exercises about adding features to legacy code Moderately Our unit test framework (CppUnit) and setup is not that good - unit tests include all header and source files and dependencies by default. We need to improve the setup quite a bit There is lots of legacy code with very poor architecture. Many classes use global and static stuff so it is difficult to isolate code under test Show
TDD for Embedded C Excellent How to write tests without modification of the production SW and without being on the target HW. Good balance Good balance Excellent In my previous lifetime, I was an Avionics Systems Engineer where I read code & made minor SW updates, but didn't do significant coding. In my new current role, I am a Systems and Software engineer with the expectation that I will become more involved with SW over time. I am giving you all of that background so I can say that I thought the exercises were great. The exercises were able to be accomplished with minimal coding background which allowed someone like myself without significant coding experience to understand and appreciate TDD. Great. I enjoyed the class. Much better I think as a company we should look to pursue it. However, since we are a medical (highly regulated) company, we would need to setup process' to support this type of development. So I don't think it will be "tomorrow", but I hope we can in the near future. In highly regulated environments, where minimal code change is usually desired because changes require regression analysis, re-execution of Validation/Verification activities, structural coverage analysis, etc. it may be a challenge to "train" management on the advantages. Show
TDD for Embedded C Very Good The concept of test driven development. We have been doing unit testing, but we were writing the tests after the code was completed. Good balance Good balance I would have preferred another day. Two days was not long enough. Very Good Better editor Personable and knowledgeable. Much better How about next Monday? There are of old school thinkers. Show
TDD for Embedded C Very Good How useful unit tests can be when making changes to code functionality. Good balance Good balance Unfortunately the course i took was only 2 days long. I would've enjoyed taking the longer version so that I could work on integrating TDD into my legacy code. Good The exercises were good at getting the TDD concepts across. Some exercises that have to deal a little bit more with hardware dependencies or other peripherals might be useful. Although this may be too specific for a public course Excellent job, I appreciate all of the knowledge sharing. Much better First step would be convincing my immediate manager that this is important (and worth the immediate productivity hit) and working to integrate our builds into the test harness. Getting buy in from all developers and the mindset shift in the development process. Show
TDD for Embedded C Very Good rationale for using TDD how to start using TDD with legacy code Good balance Good balance I would have liked more time spent on refactoring. But, as was mentioned, this course was a condensed version of a 5-day course so some topics had to be left out. Good I would have preferred different examples to those in the book. Very knowledgeable and engaging presenter that spend time to explain the reasoning behind the process. Moderately I had read the book previously, so a lot of the material was more of a review. But the in-class discussion was great and I look forward to start implementing some of the techniques immediately. Training (forcing!) myself and others to spend time implementing tests instead of only working on new features and manually debugging existing code. Show
TDD for Embedded C Excellent Very interesting concept and totally new way of developing code for me. At first I didnt think it would work for my environment but going through the exercises help me better understand the usefulness Good balance Too much presentation I really think it would have better as a four to five day course than a 2 day. Alot of information for a 2 day course Excellent Much better Unfortunately I have giving up my coding hat and do more code reviews and requirement reviews. I think we could definitely implement this on new project and it would be beneficial. Management and lack of willingness to change (we are stilling using word for requirements for most of our requirements) Show
TDD for Embedded C Excellent I had written unit tests in the past but always after the fact. Now I understand the techniques for developing the tests slightly ahead of the features of the object being unit tested. Good balance Good balance Slowing the pace in a few places where it felt kind of rushed - bearing in mind that it was only a two day course (of course). In hindsight I think 3 or even 4 might have been better. Excellent There wasn't enough time to finish them, which there almost never is in the courses I've attended. It would have necessitated more days. Very knowledgeable, very good communicator, and went with where the questions and discussions led. Much better Definitely with added unit tests to some code already developed. I don't do much clean slate programming presently so the true TDD may have to wait a bit. Resistance to change if it doesn't guarantee immediate development time reductions (even if it does guarantee higher code quality), i.e. we're more short-term than long-term oriented unfortunately. Show
TDD for Embedded C Very Good How to effectively create tests for software, while developing. Creating these tests during development means you have them the entire time you're developing the rest of your product -- which is extremely useful. Good balance Good balance Very Good Less focus on the small steps for the tests. Seemed to waste some time making the link fail while compiling every time. Liked that he always was willing to stop and answer questions, thoroughly. Much better Going to take some work to apply this to our current products. Worried I'll hit some roadblocks but we'll see. A lot of dependencies on hardware and OS hooks. Show
TDD for Embedded C Good Good balance Good balance More practival examples can be included Very Good Providing exact time to complete the exercise Interactive and provides thought how to address the scenarios Moderately Yes To make my organization to understand the benefits of TDD. Show
TDD for Embedded C Excellent It took away the hesitation to begin using TDD in my work. Good balance Good balance I probably would have preferred the 5-day course, to get more in-depth. Excellent Much better Yes My next project will be working with legacy code that is not very well organized. I'm a little bit intimidated with trying to refactor that and begin using TDD. Show
TDD for Embedded C Excellent Comprehensive overview of TDD Good balance Good balance The only suggestion for a windows test harness was Visual Studio (which I do not have). I have to do my own research to figure out how to get the tools that will work for me. Very Good Very good instructor. I really appreciate all the hints, and insights from his own experience and others as to how to think about and resolve issues with TDD. Moderately I need to identify and install some sort of test harness that will work in Windows. Again, getting a test harness environment in Windows. Show
TDD for Embedded C Very Good How to re-train how to think about writing code to satisfy the test Good balance Good balance Good I would like to see more exercise relating to lower-level embedded systems that are very hardware dependant Much better Yes, I will try to write unit tests for some of our basic algorithms Our applications are VERY hardware dependent (more hardware and I/O interfacing than software routines) which means lots of mocks and spy's Show
TDD for Embedded C Very Good unit test the code before its written Good balance Too much presentation Very Good Need more time Good knowledge about TDD Moderately NO, approval required from my manager (current schedule might delay, if I follow TDD). Also TDD environment must be setup correctly on my development platform. Convince team and current schedule delay Show
TDD for Embedded C Very Good The importance of a Test first, incremental approach. Too many exercises Good balance I would like a self-paced internet version to download and take at my own pace and a more convenient time. Very Good ? Excellent and NOT boring. Much better Yes. I'll be taking small steps with some work on existing code. Show
TDD for Embedded C Good The concept of using the test harness for unit testing. We have nothing like that and I assume it will take considerable work to implement into our infrastructure. Good balance Good balance I always get more out of courses that are on-site. Good I wish I could have worked in a group. I spent too much time on stupid mistakes that were easily resolved with a simple suggestion. Much better I think it requires some infrastructure to implement at the level presented in the course. Show
TDD for Embedded C Very Good Write test first. Too many exercises Good balance Go over real life system integration. Good Make shorter. Talk more about systems and how to deploy regression testing for a complex system. Excellent temperament. Bring it on! Definitely None that I see. Show
TDD for Embedded C Very Good Good balance Good balance Very Good Much better Not yet... there is effort occurring now to improve our compile time (much too long now) and there is also effort to put together a consistant test harness for our use. When these are completed we will be ready to roll. While management wants us to incorporate TDD into our process I haven't seen any time added to schedules for the initial work. Show
TDD for Embedded C Very Good Good balance Good balance Possibly allow a bit more time for people to unmute their phones to comment. I think, sometimes, there were times that people wanted to say something but didn't have the time to unmute to say it before you continued on. Or, it could have been their mic's that weren't functioning properly. I don't know a good solution to this, but maybe have each person say something to you to where you can hear them clearly before starting. Very Good Much better Team member's/manager's that haven't gained a true understanding to allow a transition to occur effectively. Show
TDD for Embedded C Fair Using mock to create response stimulus allows easy testing of the error paths. Not always easy to do. Also like the methodology in general - avoid code bloat trying to second guess requirements and you end up with tested code. Too many exercises Too much discussion It was longer than it needed to be for experience programmers. Good Fewer programming steps. The interesting piece was when the requirements change and you see how quickly you can accommodate that change by running the tests. focus on the methodology rather than implementation choices and programming style. Much better Yes. I can see applying this immediately. poor simulation environment. Show
TDD for Embedded C Fair Too many exercises Too much presentation Needs to focus more on _embedded_ use of TDD. We all know how to do TDD and unit-testing on simple code as was shown in the exercises. We were hoping to take away novel ways of doing things with Unit-testing such as how to cover actual threading models (not just fake them out). Fair The exercises were too easy and seemed to be catered towards the slowest of the packs (the non C developers of the group). The more advanced C-programmers in the class had the feeling this was more a C-training class than a TDD class Actually, pretty good! Not at all no. main reasons: 1. Build infrastructure requires extensive changes to allow for new unit-testing 2. We already have a (poor) unit-test framework in place but I refuse to use it (because it is just really poor) 3. TDD will not give extra bang for the buck in this environment The kind of bugs CppUnit or TDD can find for us, are simply not the ones we ever have to spend time on debugging. I cannot remember one instance where CppUnit or TDD could have saved us time. The vast majority of debugging we spend as real embedded engineers (not those pseudo-embedded engineers working on a raspberry pi beginner thing) is in debugging and characterizing undocumented behavior of custom made hardware. Show
TDD for Embedded C Excellent How to avoid bugs during code development. Good balance Good balance Excellent Much better We have to integrate the TDD into our code development process. Show
TDD for Embedded C Fair Good balance Good balance Fair Moderately Show
TDD for Embedded C Very Good I think the most useful thing I learned was using Mocks to test device driver code. Good balance Good balance Good James was great. He provided great feedback as we were working through the exercises. Much better Show
TDD for Embedded C Excellent MOCK and flow of thinking Good balance Good balance more short example and exercies be better for me. Excellent shorter and more frequent great instructor Much better yes , I try to redo some of my code now. none to remember. Show
TDD for Embedded C Very Good Quick way to create early unit tests Good balance Good balance Very Good Much better Show
TDD for Embedded C Very Good In the training it was interesting for me to see how implementation is done driven by tests. What I like is that through this approach testablity of the code is improved. what I also like is that TDD enables easier refactoring of the code. Good balance Good balance Maybe emphasize and spend a bit more time for test identification in order to show that it is also done systematically. Excellent The presentation was very good. Much better Show
TDD for Embedded C Very Good A new way to look at testing that can be easily used in the real world Good balance Good balance I would like a longer course. WebEx was ok but a lot of dropouts for me. I would prefer a local class Very Good Not that I could see. It was a well thought out example that was real world He knew his subject and was able to present it excellently. Much better not right away, infrastructure needs setup/approved Getting it put in the SW process Show
TDD for Embedded C Fair The restructuring discussion was the most useful. Not enough exercises Too much presentation I felt as though I was in programming 101 - and that there was really no way to code to the presenter's expectations. "I would have done this.." "I would have named it this..." etc... were not effective in my opinion. Fair Moderately Show
TDD for Embedded C Very Good How to do TDD Good balance Good balance Very Good Was very knowledgable and capable of teaching this class remotely. Bring it on! I can but would probably need some more hands on work to be fully comfortable with TDD. Getting the infrastructure and the management side to accept the longer development times. Show
TDD for Embedded C Good Code refactoring and waht makes good code Good balance Good balance Good A little Show
TDD for Embedded C Excellent The concept of small incremental test and development. Good balance Good balance If everyone had a Yes/No (or nodding yes/shaking no) button on their Webex desktop the instructor might be able to get responses (at least see who is responding) for questions such as "Does anybody need more time?" or "Does this make sense?" Very Good The Home Controller exercise could be simplified. I spent time figuring out the design than learning TDD. I can tell this subject is a passion of the instructor's and he projected enthusiasm and confidence. The instructor wanted everyone to succeed and provided the appropriate level of guidance during the exercises. Much better I can start some practice tomorrow. In the near term I am doing some code algo analysis on another team's code. The first thing that needs to be addressed is the long build times. Right now every build starts with a "make clean all" instead of just building the changes. This should be fixable. Show
TDD for Embedded C Very Good A new approach to incremental development that builds test suite with the application. Good balance Good balance Probably best if it were possible to get everyone together in one room. This was mitigated somewhat by the fact that the course makes heavy use of online services & materials, and we were gathered into groups locally. Still, all of us being together in a class room brings out more interaction. Excellent Not sure. He did a good job. The group was spread-out geographically, and most of us don't know the remote groups very well. We tended not to participate on the phone very much, I think, because we were uncertain who the other people from our company were, or what their attitudes were. A fair amount of distrust between sites unfortunately. The instructor soldiered-on and did get people to talk to him from time-to-time. Valiant effort. Much better Maybe. We tend to move toward particular tool-sets as a larger team. We'll want to pick & install a framework on everyone's systems. I can see how we might apply TDD to our sim environment (builds & runs on linux). Don't think we can do it on code that's loaded onto the device itself (memory limitations ... won't hold a framework). See my prior comments. Show
TDD for Embedded C Very Good I can see the mock thing for the test harness being really, really useful to us. Good balance Good balance Perhaps add a 3rd day so we have more time to work on exercises. Good I would have given the exercises a higher rating, but didn't because they felt rushed. I was not able to complete the exercises in the allotted time. You are a good presenter/instructor. Much better I'll try. Our code is riddled with inter-dependencies. Had we started with the TDD approach, we would have been able to see and remove such relationships before it got this bad. I'm not sure management will give us the time we need to refactor legacy code so it is testable. Also, we currently do not have as nice of a unit test harness as what you provided in the training. Time. Never enough time. Show
TDD for Embedded C Good The new approach to develop code. Good balance Good balance Good Moderately I believe it's not enough to only have engineers change the coding approach. Show
TDD for Embedded C Good MOCK infrastructure for HW behavior simulation. Good balance Good balance The note and dashboard environment was confusing. Something simpler to use would be nice. It was difficult to find the correct dashboard to post on. Good Moderately Show
TDD for Embedded C Very Good Test in VERRY small steps Good balance Good balance Good Material for workshop that was on a slide could be printed out or a small poster so allways avalible Much better Yes Practicing the ideas so that they become natural Show
TDD for Embedded C Excellent Practicing TDD Good balance Good balance Smaller group of attendies to allow more discussions with tutor. Legacy workshop took too long to "fly", should be better prepared (customer + tutor side) to allow faster startup. Very Good skilled, good sense for dry humour Bring it on! No, currently I´m processing sprint backlog which does not contain testing. Getting legacy code under control. Show
TDD for Embedded C Good Code refactoring and some tricks for replace the stubs. Function pointers , fake modules. Good balance Good balance Maybe it should be oriented to our code structure and limitations. We don't have so much freedome to create or restructure the files. Good Moderately Build time , many dependencies of other modules. Show
TDD for Embedded C Very Good Test before implementing, implement in small steps and test again after. Good balance Good balance Present a little more about moks Very Good Much better yes, but this is applicable only for unit test. A lot of dependencies of other modules functions Show
TDD for Embedded C Good have small steps/iterations, always tested code, have the posibility to refactor code with low risk Good balance Good balance Language could be changed to German Very Good Much better No, I'm not working very often on the code. Other things are planned in the next weeks. Show
TDD for Embedded C Good What problems TDD solves, build process(make and such), cygwin, how to test legacy code, solving compilation and linking problems. Not enough exercises Good balance More exercises. How to store the tests (version management) in order for anybody to be able to run the tests. I would like a list of frameworks suitable for TDD. (Cpputest is one of these. What others ?) I would like at least 1 exercise about refactoring code. Excellent He is ok. Suggestion: during presentation pick one person randomly and ask how they feel about the concept explained: eg: "Victor what do you work on after the training ? How would you use this concept applied to you ?" Bring it on! For my team TDD is not directly applicable (I don't do unit/ module test). Concepts and techniques I can apply: test from interface level points, build an ok interface in the code in order to have a replaceable module(unit of test). Making the boss understand that tests first or during coding must be planned as soon as a new feature starts being implemented. Show
TDD for Embedded C Excellent To learn the different reasons why tests and TDD is worth to do. Some statements are really reflecting my observations how it is going without proper testing. Good balance Good balance I don't know. Sometimes it was hard to understand what the topic is. What is the message you want to transport. But this might also be related to my poor language knowledge ;) (and it was only sometimes) Excellent The instructions were sometimes not clear enough, respectively it tooks me a while to understand what should be done (what is the goal and what is already given). So for the starting point I had to look into the slides of the training in order to understand to where it is going. Much better Unfortunately, not. I have a lot of other things to do before I can continue developing. This is related to my different roles. But I will enjoy to use the learned techniques as soon as I continue development. Huge c-files without a real architecture, global variables and high value of coupling. Show
TDD for Embedded C Very Good Development becomes easier and much more fun when we run tests and incrementally update the code rather than doing it in a stretch. This would definitely prevent a lot of grief later on. Good balance Good balance We could spend more time implementing TDD on the legacy code with tools that we usually use during our daily work. Very Good The exercises were good since we were implementing TDD on constructing code from scratch. We could have had more exercises on re factoring the tests and the code. Has been very interactive with enough examples to define the process of TDD. Much better It can be done since we have some new requirements that we are working on. But to implement this for problems in the legacy code still seems a bit difficult. Show
TDD for Embedded C Very Good Incremental development and testing gives more directive to program and resolve issues of a smaller scale. Good balance Good balance More exercises with the legacy code at an earlier stage of the training. Good Exercises could be improved if the groups shared with the other groups their improvements to TDD approach. The Instructor had good knowledge about the topics discussed and offered improvement/ alternates for problems discussed. Moderately Could start applying incremental changes of development and test cases at the earliest. The effort to get the Test environment ready for the tests. Show
TDD for Embedded C Very Good Incremental steps in coding and receiving an immediate test feedback to enable correction in a easy and quick way. Solve the error which is at your face rather than trying to fix all errors at the same time Good balance Good balance Providing enough time to practice training exercises Very Good I feel it is well structured Good job. Thank you. Moderately Yes, I can start tomorrow as I am moderately good with the concepts. May require additional effort in the initial days. Time management Show
TDD for Embedded C Good A new approach to write good code! Good balance Good balance it could be more useful and convincing to show some examples how the projects work after appllying TDD. I know it´s not your job to convince. :-) Good help us to set up the test envrioment more clearly and quickly, quite confusing ant time consuming when we try to make our legacy code combine with Cpputest and make it run. Moderately As an integration tester, TDD is more suitable for the unit test. Try to integrate this method into my routine job when it is possible Show
TDD for Embedded C Good how to start a refactor task, how to encapsulate things Good balance Good balance Very Good the excercises are fine, just a wrap up how the final result should be done Moderately yes getting it working with our process Show
TDD for Embedded C Excellent The need to split up large source files which should be tested. Good balance Good balance Choose people which are interested in the course (and don't delegate uninterested people) Excellent Explain before the exercise more the code which is already in the example, so we know better where to start. And what should be achieved with the exercise. The instructions could be improved. Good knowledge of what he is talking about. Moderately No, because it is Saturday. But on Monday I can. The large files which is hard to bring under test. Show
TDD for Embedded C Very Good Letting the test drive the development. Good balance Good balance Excellent They were at the right level of difficulty and were good examples. Good time management, did not let us get bogged down in exercises, managed to provide personal help, diplomatically fielded stupid questions. Seemed somewhat defensive when arguing in favor of TDD to a group that had already paid for the course. Much better Yes. Climbing the TDD learning curve while trying to produce real code on real schedules. Show
TDD for Embedded C Fair Good balance Good balance Fair A little Show
TDD for Embedded C Excellent The concept of small programming steps followed by refactoring Good balance Too much discussion make it longer (3 days?) Excellent at times it was a little confusing what instructions to follow. I liked when the instructions were in comments and you just deleted them as you progressed. very interesting - nice mix of instruction, examples, and experiences Bring it on! I would like to start but I am in a group environment so I am reliant on others to commit to this as well - plus not everyone in our group has done the training code space is severely limited - less than half the group is trained on TDD Show
TDD for Embedded C Very Good The info on Mocks was very interesting and useful. Good balance Good balance The code editor of the CyberDojo system is very basic and could be improved. E.g. just auto-indent would be a major improvement. Very Good I don't think they need improvement. Good, spoke clearly, kept the class moving. Moderately Can't start tomorrow because we don't have a native build framework in place. - Updating build system to support native OS build of the tests. - High coupling of codebase. Show
TDD for Embedded C Very Good By minimizing time from coding to test you minimize time to find/fix the bugs. Good balance Good balance Get his network working faster. Excellent More use of named enums as type definitions instead of anonymous enums or #defined values used as ints. (Seems a bit shoddy). Using enum-defined types for function parameters allows type-checking and promotes error-checking at the compiler level. Just using int values as parameters allow accidental mixing of values that might be a mix of test-code and production-code definitions. Just would like to give a kind reminder that there are multiple ways to do things - and that 'correct-by-construction' helps code. There's a lot to be learned from the attendees. Thank you, and hope your daughter's wedding is a super wonderful time. Much better I can always start tomorrow. Time limitations, legacy code. Will have to carve out my own time to try to build an initial infrastructure for TDD build/test on the development system. Would try putting in one routine/file at a time (apart from the main code-base). Middle management wanting TDD but not realizing that it requires the very thing they have directed us not to do in the past: a system on our development machines to perform initial TDD tests off of the hardware systems. Show
TDD for Embedded C++ Very Good Learn new ways of tackling development problems. Will really help with future refactoring work. Good balance Good balance It could have a few more official breaks. I felt like I was stuck in my chair Very Good The editor is terrible for coding. Where are all my shortcuts (Use gvim) Much better There would be a lot of legwork needed to actually get to the point of running a unit test. Other Coworkers Show
TDD for C Good TDD Concepts Too many exercises Good balance Fair Refine Exercises to focus on TDD concepts ONLY without other coding issues that are not related to TDD. That would better highlight TDD concepts. Moderately Show
TDD for Embedded C Very Good The mechanics of the cpputest harness. Good balance Good balance During the presentation portion of the training, more real-world examples of development done using TDD would be useful. Excellent I appreciated the clear enthusiasm the instructor had for TDD. Much better No, because I have a deadline tomorrow. However, I should be able to practice with TDD after that. We have a large legacy codebase, and we would also have to implement test harnesses for both our embedded C projects and our python support suites. Show
TDD for Embedded C Very Good Leaving old implementations in place while developing new features to keep the code testable. Good balance Good balance Very Good Much better Yes, our development flow is set up such that the 'writing tests' step is before the 'in progress' step. The steps in our development flow are listed a bit more discreetly (tests then code) where TDD would probably be a bit more iterative (write test code, write code, repeat). Show
TDD for Embedded C Very Good The pattern to incrementally improve something while keeping the tests passing all the time. Good balance Good balance James should have practiced drawing things before trying to draw a diagram with the whiteboard thing to present an idea. Since I catch on to ideas very quickly, watching him fumble around and take time to do something that wasn't very helpful to getting the idea across was painful. Excellent Can't think of anything Should have discussed lunch break length during the "Formalities" part of the course. In Boise, getting lunch in 1/2 an hour was challenging. Would have preferred an hour. Much better I'm able to personally, but I can't because our TDD infrastructure is lacking. We currently cannot get the immediate feedback which is necessary for incrementalism - it is more like 5 minutes. See above. Show
TDD for Embedded C Very Good Good balance Good balance i dont feel 2 days is enough. it is too much info to absorb in that time and doesn't give enough time to practice exercises. Very Good Moderately Show
TDD for Embedded C Very Good Using unit tests as a way of organizing and validating your code as it was being written, rather than writing code from your set of requirements and then unit testing it later only to find it laced with bugs. Also an intro on how to properly mock/fake functions out for unit testing will go a long way. Good balance Good balance Maybe more time to work on the exercises to ensure that everybody can finish them? I understand this was probably limited by condensing the course into a two day period. Excellent N/A Very engaging instructor. Did not spend too much time on slides explaining the concepts. Instead gave a slight overview of the topics, then jumped into examples, and then let us practice the exercises. This is a much more effective learning practice rather than just throwing slides at people, so I enjoyed that. Much better I cannot start tomorrow, as I am working on some system based work right now (Interprocessor and threading communication), so a unit testing approach doesn't make much sense in this work. But in the near future I'll be working on true feature development that is a little easier abstracted from the system, so I look forward to using TDD on this work. Lots of code that has already been written, so lots of stubs/fakes/mocks may need to be written to move development off target. Show
TDD for Embedded C Very Good Solve one problem at a time Good balance Good balance More descriptive text on the slides Very Good Providing an exercise book (PDF) with all the exercises and solutions Very prepared Moderately Depends on the project Working on non modular legacy code require to much refectoring effort. Show
TDD for Embedded C Very Good It was very well structured and balanced with just enough practical excersises Good balance Good balance Very Good Excellent delivery and always willing to explore specific areas in more detail. Much better TDD is a practice that we will be putting into our processes for new projects going forward, there is a lot of cost in refactoring legacy code, however we have made a business commitment to tackle some of the high risk areas when they are next modified. Show
TDD for Embedded C Excellent Good balance Good balance Very Good Much better Show
TDD for Embedded C Very Good To not be afraid to give it a go. Good balance Good balance Very Good Much better Intending to start ASAP Show
TDD for Embedded C Excellent The tests I have written to test a small piece of functionality after writing the main code should not be discarded once the tests pass, they can be combined with other tests to create a test suite to ensure future changes do not break the previously tested code. Also, changing to write the tests first before the code provides a much better return on time invested as the tests should catch the bugs before they are introduced, so the time spent hunting for them is reduced to almost 0. Good balance Good balance I was lucky enough to read a couple of chapters of your book ahead of the training, so I feel like I had a slight advantage in the initial exercises over some others who had never even heard of TDD before. I feel like I was more open to the concept after having done some background reading, so if possible, the books could be delivered a little ahead of time. I am aware that this is not always possible, and even if it is, some people just don't have the time to do the background reading, but overall it should help more people. Excellent I lost quite a lot of time due to the quirks of Cyber-Dojo. If it was possible for the editor to behave more like an IDE, it would be great. Simple things such as as tabbing in to the correct level after pressing return, or auto indenting after typing "{" character. I don't expect anything too advanced, but these few small changes would make quite a difference. James' approach was great. He always seemed very knowledgeable of the subject and was able to answer all of the questions we had. He made watching someone writing code seem interesting and he knows a great deal about other related topics for those of us who have experience of other languages (comparing some of the pointers within structures tricks he used to C++). Much better Yes I can. Most of what I work on is legacy code, so taking the time to set up some tests before I start modifying the code is going to be very helpful for me. Many of the changes I make to the code are very small, so the amount of code that would need to be refactored before I can write tests for existing code is quite large. Although it is a hassle, it may be more time effective to rerun the manual tests for some code instead. Show
TDD for Embedded C Excellent The whole strategy of TDD: how the process eliminates problems as it progresses rather than leave it until an indeterminate later point. Good balance Good balance Some pre-course guidance on creating a real example of our code to be worked on later in the week. Alternatively, a follow up workshop where we have had a chance to try TDD on our code would be very useful. Excellent Using our own code as mentioned above. James is very knowledgable in this subject and was easily able to answer all our questions. Also his extensive general knowledge of embedded coding was extremely useful. The topics were clear, understandable and well presented. Much better Unfortunately the existing pressure of work on specials for legacy products means that I cannot make immediate use of TDD. However, I am very hopeful that the next special will be able to make use of TDD! My particular area is concerned with maintenance of existing products and it is not likely that time would be allocated to re-factor the entire instrument code. Also at least one instrument has run out of code space to such an extent that is has already be hand optimised to save space. New product developments are most likely to be able to make use of TDD. Show
TDD for Embedded C Excellent To think more carefully about software design, how to structure the design. The importance of design from testability, to maintainability (the requirements change, the software needs to be changed accordingly and the easier it is to do with good design and full test coverage). Good balance Good balance Having said "good balance" on exercises, which I think is generally true, would like to have seen exercises tailored specifically for our development environments. We touched on this on the final day but would have been useful to done one of the examples in (for us) Visual Studio Very Good Already commented, tailored for our development environments Very good, well structured, very knowledgeable. Easy to listen to and follow. With a mixed group, it can be difficult to assess the pace at which to deliver the training. At times, I personally thought we going too slow and at other times would have liked a little more time to think through the exercises and design constructs. Certainly not a criticism, just shows how well the time was used. Bring it on! Already started to try it at home, have a new enthusiasm for software design. Will embrace TDD with the next design task. Have been writing IEC61131 (ST), need to consider how to implement some of the design constructs that come with TDD. Does the test framework give similar functionality for mocking for example Show
TDD for Embedded C Excellent Learning how TDD can be used in areas close to hardware, using mocks and substitutes. Good balance Good balance I wished I was pointed to the provided material prior to the course, so I could have some preparation (e.g. about using linker to substitute and mocking methods). Excellent For the given time available, I can't see any change that could (certainly) improve the exercises. The concepts where described clearly and in a easy to understand way. The instructor looked at the problem through the trainee's glasses, which was very useful. Much better Yes, surely, the sooner we start, the better, while the concepts are fresh in mind. Challenges related to legacy code and that as, a new starter, I will be slow. Show
TDD for Embedded C Excellent Should have more granular test cases to pin point a problem. Good balance Good balance Very Good Personally I find making Light scheduler generic quite hard to understand. Very good trainer as he know how to drive a bunch of people. Much better ofcourse , why not :) NA Show
TDD for Embedded C Excellent I learned that TDD can be used in areas I previously thought would be impractical Good balance Good balance I throughly enjoyed the course, I cannot think of any improvements Excellent Described the concepts in a clear and easy to understand way Bring it on! Some intial loss in productivity as we develop our TDD skills and overcoming issues with getting legacy code into the test enviroment. Show
TDD for Embedded C Excellent How to perform TDD on legacy code and use in our environment Good balance Good balance Excellent Bring it on! No, its weekend... don't want to encroge on my drinking time :) Legacy code base Show
TDD for Embedded C Very Good The process for test based training and the mindset to write tests first before functional code was very educational. It took some time to buy into the concept but found it to be very conducive to fast and error free Firmware development. Good balance Too much presentation I took the course online along with few of my colleagues. we reserved a conference room to work in pairs which was very helpful. There was an initial emphasis on being on mute to reduce noise in the system when the instructor is presenting. This was a big deterrent to have spontaneous discussions on the topic and answer general questions since we had to un-mute the conference system to speak. We ended up participating less verbally. We realized this was true with everybody else on the call as well. Very Good An overall requirement review at the start of the exercise instead of finding the next requirement based on the next test will help with a big picture perspective. I understand that this may make people to get away from TDD process but it’s a good exercise to force the developer to make the minimum changes for the current testes to pass instead of more development to accommodate future tests based on requirements. James was very knowledgeable. Much better Yes. I'm more inquisitive of the Tests we have in place and started looking at ways to expand our unit testing infrastructure. Show
TDD for C Very Good The most useful thing I learned was the technique of starting simply and using the unit tests to validate every detail of the system. Then while you're building up the functionality, you always have a strong base to trust in. Good balance Good balance The course was great, thanks. A small thing. I like to see an overview of the technique at the top of the slides, and maybe again in the middle of the presentations. Just helps me organize what I'm seeing. Very Good The exercises were mostly very helpful and illustrated the points well. I had a difficult time with the section on the mock. I think the problem was mostly me, because I had to change location during the day and lost my rhythm, having a hard time getting back into it. I had a difficult time with what the mock was doing and where tests were supposed to go and what I was supposed to be expanding. Maybe take a look at that section, see what others think, see if some clarity may be added. James was knowledgeable, friendly, and patient. Thanks! Much better I may not be able to start tomorrow because mostly I work on existing code, and I need to become more familiar with our unit test structure. There is a push to create unit tests, but we're in the middle of the transition. Pre-existing code, little support, big push from managers to hurry. Show
TDD for Embedded C Good I learnt that developing the test code before developing the actual code leads to the defect free code. TDD helps in doing so. Good balance Good balance I just attended a 2 day workshop, but this course can be best done if it is for more than 3 days or so. Good very talented, addressed every concern tat was brought up during the training Moderately I can start adding unit test cases in my code and verify the actual code modules step by step. but it is going to need a lot of effort. it is very challenging. it is going to need a lot of effort. Show
TDD for Embedded C++ Very Good Design concept and develop the skill to build the test framework from the ground up Good balance Good balance The design of the course is very good. A bit short time for the mock testing (the last module). Overall it is a very good course to take Excellent The last module (mock testing) a bit rush by the end. But everything is excellent Very helpful and excellent instructor Much better I applied the OOP concept. It is very impressed. To build a framework is not that simple. That is the challenge. Show
TDD for Embedded C Excellent I have already been practicing TDD on my own, but I learned that my cadence is a little too long, with too many changes at once. I also got a lot out of the flash driver exercise - I can now see how to apply that to some problems I have to solve in the very short term. Good balance Good balance It felt like we were trying to pack too much material into the allotted time. I was able to keep up due to my experience, but I saw two beginners struggling to keep up, and eventually they were lost to the point that they were in the room but working on other things (on the second day). I plan to work with them as much as I can. Before this class, I didn't have as good a grasp of their programming experience as I thought. It might be a good idea to have a separate beginner class and master class. You could delegate the beginner class to someone else potentially. Also, it was necessary to keep the audio muted most of the time, which hindered discussion because it required an extra action of un-muting the audio before speaking each time. Excellent If you were to start out pairing participants together (which could be a challenge due to technology limitations), that might help. I was impressed with cyber-dojo overall, but the editor could be better, as you mentioned. Also, if there were a way to pair two animals together within cyber-dojo, with a built-in IM feature, that could facilitate pairing in the exercises. The content of the exercises themselves is nearly perfect, in my opinion. In a word, outstanding. Bring it on! One thing I am missing is setting up the test framework and build process to incorporate into my current project. I can start building that today and then get started in the cadence. Hopefully that is something I can accomplish in a day or less. It helps that there is another agile team working on web apps - that means there is management support for the process. Being the only purely software guy in my group, I have the freedom to implement this for myself. My main challenge is persuading others to also do it. Also, other tools besides C/C++ are used to create behavior. For example LabView and vendor-specific ladder logic tools. I also need to find ways to implement a TDD cadence for these environments, or find a way to transition away from them. Show
TDD for C Good Learning what TDD is intended for and what type of tools are available Good balance Good balance It would have been nice to see some of the code ahead of time. If it was available I missed it. I also was told I was going to the class <24 hours before it occurred. Good Providing a solution to work from after completion of the test for a more elegant solution. While talking with students was at times helpful, while trying to learn the concept to have continual talking made it difficult. Moderately Yes, I can on my own time. We are just starting up a project, and management things TDD can be used for the entire project. I do not think that it can be all the way to the GUI testing. Show
TDD for Embedded C Excellent How to develop the test before the code. Good balance Good balance 3 more days Excellent N/A Clear and good delivery of the material. Convinced me that I should be using TDD. Much better Yes, I gained enough knowledge to start messing up and learn more. Corporate culture Show
TDD for Embedded C++ Very Good Clean code, smelly code, TDD principles Good balance Good balance Very Good More slots so that people can work more independently. The driver-passenger seat is nice but it would be better if we have the option to try some things ourselves I was feeling like some times he was trying to "force" a "fun" atmosphere. The crowd wasn't very responsive. You don't have to always "break the ice", not with all of the participants. Much better I have the principles, but I still need to setup my system, and take small steps to write the first tests from scratch. It is going to take a while. Tones of legacy code and lots of dependencies. I will try to isolate some code and give it a try Show
TDD for Embedded C++ Excellent I got actual hands-on experience on Cpputest starting from a simple, guided example down to a more complex one. Good balance Good balance Very Good I think the instructor caught us pretty quick when we were stuck and gave some pointers in how to continue. I liked that he didn't tell us errors directly but rather led us down a wrong way knowing it will lead to an error later on. Much better Regarding knowledge: I think so. Regarding day to day use: Let's see. Regarding actual use in my day to day work: I can use it for MY day to day work, but I doubt it might be applicable in the overall system as the use of TDD seems like a huge paradigm shift. Show
TDD for Embedded C++ Good how to use TDD in our project to minimize bugs as well as improving the quality of code. Good balance Good balance Technology specific lectures may be included to let us understand that how TDD can be used in our current projects(e.g nfc). Very Good Explaining concepts clearly and helping to understand concepts related to TDD. Much better Yes . I can start but need to understand more how TDD can be applied in C and Java based sources as our project is not only C++ based. NFC is a complex RF technology . In some cases it is difficult to mock/stub out all features. Show
TDD for Embedded C++ Very Good Test framework to setup unit test environment Good balance Good balance Excellent Much better Show
TDD for Embedded C Excellent Almost, lots of interesting parts as I have covered these topics before but do not practice much. Most interesting thing for me was the cyber-dojo and the test framworks, e.g. cpputest Good balance Too much presentation Towards the end there was slightly too much presentation Excellent More time to complete Very good presentation style. Though could assume less, i.e. called a Taiwanese, Chinese. Opps! Bring it on! I will do this at home because I can not see it happening at work, unless management pushes it. Most things you have taught, I have pushed in the past and been shouted at, only for the same person who shouted it down to claim it as his own idea! Depends on your team lead/manager. Its very political here. Show
TDD for Embedded C++ Very Good how to do tdd how to write tests for legacy code Good balance Good balance the slides that we received in pdf to have space next to them for notes. Very Good light scheduler was a bit difficult at the beginning, we had to write both the tests and the code. would have preferred more a driver example with i/o ports that we can learn to spy on and maybe messages being passed to it via an api James was great, although sometimes jumping between slides which made things difficult to follow. Bring it on! yes! legacy code filled with custom APIs Show
TDD for Embedded C++ Excellent The most useful is how efficient and developed code would become if we implement via TDD methodology. In the beginning it might look an overhead but ultimately it a lot of gain in term of Bugs captured during the development. Good balance Good balance If one factor be emphasised more that how to implement TDD in the existing code base. Excellent I am happy with the excersies Excellent presentations and course structure Much better YES, its always sooner than later and it only comes with practice and implementation not mater how difficult it seems to start Complexity of the existing code base and time constarints Show
TDD for Embedded C++ Good Good balance Too much discussion Very Good Moderately Yes. I'm already working on tests and was in the middle of doing this before the training on the new software component I'm working on. Show
TDD for Embedded C++ Good Good balance Good balance Good Much better Show
TDD for Embedded C++ Very Good Good balance Good balance Very Good Moderately Show
TDD for Embedded C Very Good Spying and Faking Technique. Braeaking dependencies Good balance Good balance More example of the concept being teached in term of practice and coding. This make the participant more easily understand the concept Very Good Prefer to do more exercise and start in a small increment with each step Great instructor will 2 way communication Moderately Sure. Why not? But it may take some time at an early stage. People may refuse to change. Most people still work in structured and traditional way instead of OO. Show
TDD for Embedded C Excellent How to manage hardware dependencies on the software and how isolate the different components and achieve hardware independence during unit tests. Solve One Problem at a Time. Good balance Good balance As the people attending this training works on completely different projects with different architectures, I think on the first day the students should do a short presentation about the system they are working with. I believe it will help during the training as it will be easier to understand the needs of everyone from the training and adapt the concepts based on the target systems. Very Good The build environment could be better explained. For a few times I felt confused about the context of the functions and variables used during the practical exercise using the Cyber-Dojo. I really like the use of the Cyber-Dojo as the platform for the training. It makes zero effort to make everyone have the same running development environment. Much better I was already using TDD for my C# developments. But now with this training it is much clear how to handle with hardware dependencies and it makes my understand much better the challenges to apply TDD during our PLC software development. We support a legacy PLC software project. As there is no a lot of information about how to apply TDD to PLC development and the PLC software was not developed with the unit tests in mind it is really challenging to apply TDD on it. But we can see a way to do it and we are working on it. Show
TDD for Embedded C Very Good we can get more idea about how to test our codes and how to design our code structure for improving code quanlity. Good balance Good balance Good Bring it on! We can, but we have to think much on Function block/system isolation at first. quite difficult to define the testcase for our whole control system ,it is better to just start form function . Show
TDD for Embedded C Excellent I have learned a new way to develop programs. Good balance Good balance Maybe the course can provide more varieties of program language and environment such Matlab and PLC. Excellent Much better I am programming on PLC, there is no integrated test environment for PLC because it heavily reply on hardware and process. Show
TDD for Embedded C++ Very Good The introduction of TDD in software testing, exploring potential in different programming environment. The cyber-dojo is perfectly built to assist the class learning. Good balance Good balance Special group or separate session for those who are not so well verse with C programming to cope with the pace of the exercise. Good program code answer at the end of each class to help participants revise and refer to the concept introduced. Exercise in Cyber-dojo is temporarily and couldn't be retrieve for future reference and learning. Well versed in the subject taught, provide ample rest time for better learning curves Much better Yes, the course drives the mindset to consider the steps in unit testing whenever we start to deal with codes, be it a legacy code or developing new code. The testing environment and language, legacy codes, interactions with different level of programmer. Show
TDD for Embedded C Very Good TDD: get your code to do what you think to do. Solving one problem at a time. Good balance Good balance More detail on complex product code; Very Good Better give out the exercise and backgroud two weeks before the training so that people can make better preparation. Good TDD idea; Much better yes, actually I started from the workshop already. The risk and schedule. Show
TDD for Embedded C Very Good How to create the test project with cpputest. Learn how to refactory the legacy code. Good balance Good balance The course is good. No comments. Excellent The dojo is excellent. I think it's cool. No comments. Great. Much better Yes, I will use TDD in my work. Write testcase at first. Change my mindset. Show
TDD for Embedded C++ Very Good - resolving difference build problems with difference substitution method. - refactoring. Good balance Good balance - provided small notes or small booklet for all cpputest reserved codes like explain what is/how to use on e.g. expectOneCall, LONG_EQUALS and others. - free coffee provided in the class room. Good good job! Much better of cause. - not given enough time for tdd backlog, not trying to convincing engineer to to learn/do tdd or agile principle. Show
TDD for Embedded C++ Good Good balance Good balance Good Much better Show
TDD for Embedded C Very Good 1. Fast testing of small chunks of codes. 2. Add production code that was tested first rather than tested last. 3. Ability to do off-target testing Not enough exercises Good balance 1. Add more exercises. 2. Can send a pre-course package to install environments (cppUtest, install guide for different environment) 3. Sometimes the presentation stuffs seemed to be a bit rushed. Excellent 1. The exercises are good and TDD concepts can be understood and experienced through them. Maybe you can add more exercises. 1. Easy to understand. 2. Takes time to explain. 3. I feel some parts of presentation were rushed. If those parts were just for information then we skip them over and read them offline and spend more time on exercises. Much better 1. I can start testing my code immediately using TDD concepts. 2. The source already has CXX TEST framework and compiling one module only is possible. 3. Difficulty is to add simulation function(these also needs to be tested...) for supplier provided intrinsic function 1. Some portion of the code my team works on uses heavily to assembly function and intrinsic function. 2. Once of the biggest constraint for our code is execution speed(this can only be measured after running on target). So even if TDD says the execution passes all the test, if the performance is not optimum we will have to change the code. Show
TDD for Embedded C++ Very Good write test case and implement code in piece by piece. write test cases according to a flow chart. Good balance Good balance Explanations were well provided, think nothing much is required to be improved. Very Good informative, good presentation skills and well explanations. Bring it on! Can start by today too many dependencies on legacy code Show
TDD for Embedded C Very Good learn TDD concept and clear some doubts Good balance Good balance Very Good more stable/reliable server. :) knowledgeable guy that can guide us on TDD, clearing the doubts, teaching the way to solve some problems which will be faced if deploy TDD Much better we are trying out TDD with CppUtest, and we will continue to drive TDD with better understanding on TDD legacy code, dependency problem. Show
TDD for Embedded C++ Very Good what can be tested and what not and the granularity of test Good balance Good balance Excellent Moderately Schedule. I understand that the time cost is different between fixing it now and then but sometimes, the time allocated for is challenging to meet HW team or factory request timeline. At times in that scenario, we even take risk to skip doing the unit test. Show
TDD for Embedded C++ Very Good Clearing doubt about using TDD for embedded C++ and how it can be applied effectively. Good balance Good balance Good Much better Working with legacy code that has terrible dependency mess. Show
TDD for Embedded C++ Very Good creating small test case from a flow chart which I've never done before. Good balance Good balance more examples on creating test case from requirement Very Good The requirement is not clear for the 1st exercise. Even though there's steps on creating test cases. Details requirement. Much better Ya. I will try to start tomorrow. But firstly we will need to set up the framework. Show
TDD for Embedded C++ Very Good Learn about the way to perform TDD by solving one problem a time. Good balance Good balance Excellent the exercise can involve more different technique of solving the problem for the test case, such as private function. A little Show
TDD for Embedded C++ Very Good clear my through about TDD. learn to know how to work on legacy code and bug fixing with TDD. Good balance Good balance it's better if give us the history/background of TDD. and relationship with agile. Very Good help to deploy TDD on our own project. Much better Show
TDD for Embedded C++ Excellent 1. Writing good test cases with TDD 2. How to identify good designs and how to fix them 3. How I can make my legacy code more testable Good balance Good balance Excellent I really like the exercises. Maybe more but shorter exercises so that we tackle a wider range of problems You inspired me to be a better programmer. Bring it on! Yes, I'm already starting practicing TDD right away after the first class. Schedule - something that I will need to influence the people doing the project planning to plan for more time in development and shorter time in bug fixing. Show
TDD for Embedded C Very Good The practice help me to understand how to use TDD. Not enough exercises Good balance More exercises on Day 3 regarding the OO and legacy code. Excellent Much better Show
TDD for Embedded C Very Good Knowledge and hands-on experience in TDD Good balance Good balance Excellent James is an excellent instructor. His knowledge in the field is outstanding and as such, he is able to provide guidelines on the steps required to solve problems in testing legacy code. Much better Yes, I can start injecting TDD in my work. However, it will take some time to practice writing good test cases and then creating awareness in encouraging people to do tdd How to write good test cases, how to encourage people to do TDD Show
TDD for Embedded C++ Excellent I learnt the correct way to do the development using TDD. I understood the motive of TDD and learnt how to write tests along with codes. Good balance Good balance Excellent Much better Yes. Our project is already planned and we have not budgeted enough time in our development cycle. Thus we have less time to write good UTs. Show
TDD for Embedded C++ Very Good TDD framework and how to make use of CPPUTest for TDD Good balance Good balance Excellent Much better Show
TDD for Embedded C++ Very Good TDD methodology, hands on experience, and problems we faced and will face are solved Too many exercises Good balance More real life examples Very Good If possible, use real life challenging examples Much better No. Already started. Real life situations sometimes can be more complicated than simple examples Show
TDD for Embedded C++ Excellent How do TDD with CppUTest. And how apply some of the OO concept during TDD. Good balance Good balance Excellent Much better yes. Legacy code Show
TDD for Embedded C++ Good The nuts and bolts of using cpputest, and the basic TDD methodology/philosphy. If I get nothing else out of the course, I at least will know what "TDD" means. Least useful: Design patterns. Too abstract - what USE are they? Good balance Good balance Tone down the level of abstraction in presentation and exercise examples. Don't use sub-sub-sub-...-classes to demonstrate something where a simple single class will do. Try to stress the practical more. Good Early sample problems should provide more hand-holding, perhaps even down to the "enter this now" level (or close to it) to help people get more used to the syntax before they actually have to think about application. James has a (mostly) down-to-earth presentation style that I appreciated. His willingness to interrupt his presentation to answer questions or explain things in more detail was appreciated. A little I can try these techniques on code that I write as part of my learning C++ exercises (this is a self-study I am presently working on). I do not see how I can use TDD techniques on legacy code. Too complex/difficult. Some unit testing is used in our present codebase, but not everyone is up to speed on TDD, and there may be some resistance to adoption. Will I be given the freedom and granted the time to learn and adopt TDD methods? Show
TDD for Embedded C++ Very Good This new (to me) mindset for code development methodology. There is much that I feel I did not absorb, but what did sink in will prove helpful. Good reminder of some basic software development concepts. Good balance Good balance I would like to see more direction given in the exercises (see next text box). Good Maybe it's just me, but I struggled quite a bit to understand what I was supposed to do in most of the exercises. <rest of comment deleted, I will email it to you> Instructor was excellent. He knows his stuff, is very engaging, and made it as unboring as possible. Moderately Probably. It is different from how I have approached engineering problems my entire career. But I will give it a shot! Show
TDD for Embedded C++ Excellent I knew that dependency injection was great for decoupling objects but I did not realize that decoupling makes platform agnostic testing possible. Good balance Good balance I would like to learn a little about testing frameworks or practices in other environments. Maybe there are things done in those environments that can help me solve tricky problems! Excellent I wish I could have performed these exercises in my own dev env. I know you'll never do this since this is a setup nightmare but maybe allowing those who can checkout the code to do the exercises in their own env would be helpful to me. I think you are very knowledgeable and helpful instructor. I learned more than I thought I would about TDD; I spent a year working for Brett Anno (Zebra) who I thought hammered into my brain everything I needed to know. I was wrong. Bring it on! I am able to start tomorrow. I am almost always given the ability to implement the features or changes assigned to me using whatever methodology or philosophy I choose. I know I will probably not be able to write tests after-the-fact for our untested legacy code. I'll be scared to refactor this. I will be TDDing for everything new I write! Show
TDD for Embedded C++ Excellent The difference between TDD and test later development. Often times in our office TDD has been associated with writing unit tests later but TDD is much more (and better) than that. Good balance Too much presentation Some more interactive examples on exploiting each of the different boundaries in your code for testing. Good Very good. Helpful with ideas on how to test specific situations that occur in our environment. Bring it on! No, tomorrow is Saturday... Yes I would like to start using TDD more when fixing issues to have quicker feedback on small changes. I would also like to use it for some of my hobby projects. Long build times, seemingly large effort required in stubbing out OS calls for running UTs on host platform. Show
TDD for Embedded C Very Good TDD, break down to small steps. Good balance Good balance Maybe have some prerequisites, like read certain books.Maybe have different difficulty level for different background personnel.I was OK with the beginning part and first test, then got lost after.feels like I was put in a jungle totally new to me. Very Good pretty good already. very knowledgeable. Moderately No, I'm not ready. Still trying to grab the concepts and how to apply to real world. Will keep practicing though with the examples. We have pretty complicated system so far, how to break it down to apply unit test to it? Show
TDD for Embedded C++ Very Good Step by step methodology for developing code with less up front bugs. Good balance Good balance Clearer objectives in notes of examples to be less ambiguous as to the goals of each step Very Good see above Great ability to express ideas and keep the topic interesting. Intimate knowledge of the in's out's/mechanics of the c++ language which was interesting to learn in parallel to the TDD Much better Yes, but will take effort to prioritize balance of long term benefits of these methods vs. immediate fires Show
TDD for Embedded C++ Very Good How I can drive design and development of software using concepts of TDD. Good balance Good balance I think this course can be improved by including more real time problems/examples. Very Good Design patterns are important for software development. Since TDD is driving software development, I think it will be a good if you include more exercises related to design patterns. Bring it on! Yes, I am ready to start from next project. Show
TDD for Embedded C Very Good TDD is supposed to be done in a much more iterative way than I'd previously understood. I'd heard it described in the past as "write your tests before you write your production code," which implies writing ALL of your tests before ANY of your code. Good balance Good balance Very Good Some instructions were missing. Strange sense of humor. It can sometimes be good to be self-deprecating. However, it's rarely good to be condescending/use "proof by intimidation." Much better Yes. Having the framework pre-installed with a fair set of tests already written makes it much easier. It would be much harder if I were starting from scratch. Buy in from team members. Large installed legacy code base. Show
TDD for Embedded C++ Excellent Just learning the basic concepts of TDD, as I was unfamiliar with it prior to the class. Good balance Good balance Excellent Very knowledgeble. Presented real-world examples of how to implement TDD through examples. Much better I can certainly attempt to implement some of the TDD concepts on my own, perhaps on some standalone code, until I become more knowledgeable about the production code. I am new to a group that has been using TDD for quite some time; so, I think the only challenge is my own learning curve. Show
TDD for Embedded C++ Excellent Dealing with legacy C code; C++ mock frameworks. Good balance Good balance Maybe taking time to review/work with some code from our code base to get advice on making certain patterns (or anti-patterns) we use testable. Very Good Improving the editor would go a long way - tabs/undo didn't always work, etc. Funny, knowledgeable, and a good teacher. Never failed to provide salient input on topics and questions raised by attendees. Bring it on! For some things, yes. New code should be easier to test drive, now that I've had more experimentation and hands-on time. Maintaining legacy code will be fun but a good opportunity to apply TDD on old code and revise it in manageable pieces. Trying to get buy-in from colleagues who are less apt to try it, and ensuring we don't break anything while getting over growing pains. Show
TDD for C++ Excellent I honestly learned a number of C++ fundamentals in this course. Despite that possibly hindering the intended meaning of this course, I feel like it laid a great foundation to my C++. Good balance Good balance Maybe slightly more exercises. This is because I am personally bad at paying attention to slides but am enjoy participating in exercises and learn a lot from them. The amount of slides probably was not bad for other people. Excellent I honestly really enjoyed the exercises. They built up on each other in a good manner and they were down to earth enough to not feel like pointless theoretical exercises. Much better My issue with starting tomorrow is the amount of code I write. I am in the custom applications group and have a mix of coding/paperwork/coordination/waiting. Coding gets the smallest piece of the pie/ The biggest challenge is legacy code. Show
TDD for C++ Very Good This was so new for me that everything was interesting although I quickly found out that I am not the C++ programmer I should be. Good balance Good balance Listing of prerequisite knowledge. That may have been provided but I did not see it. Very Good Excellent instructor well versed on the topic. Easy to listen to. Answered questions.. A little After discussing with TDD experienced co-workers, I will attempt with their help Legacy code. Show
TDD for Embedded C++ Excellent It was a good refresher on what I had already learned. Good balance Good balance Very Good Nice guy Much better No, tomorrow is Saturday and I will be at the fair. Skeptical employees who fear change. Show
TDD for Embedded C Excellent Learned about the test framework Good balance Good balance Not sure - was good to get into the hands-on work quickly Very Good All good Much better work priorities Currently working on small, legacy firmware issues - not sure if it is worth developing a framework for these situations. Show
TDD for Embedded C++ Good Don't overthink. Go slow to go fast. How to integrate CPPUTest into my environment and actually use the test harness framework. Good balance Good balance Walk class through more small examples to start. For the light controller/scheduler exercise, just give the design so the focus can be applying TDD, not SW design. Good Add a few more C++ examples. Need to better define and explain use cases for Spies vs. Fakes vs. Doubles. I'm not sold on Mocks as defined in class. Maybe I still don't see the value there. Moderately Yes. I see the value. Getting management to understand the learning curve. Just b/c we are trained doesn't make us experts in TDD. We need to do it...and fail at it a few times before we get good at it. Show
TDD for Embedded C Very Good Creating requirements list and not wavering from the list using TDD. Good balance Good balance Very Good Knowledgeable on all phases of the programming development cycle. Much better Yes because I can revisit existing code and improve the code through TDD and refactoring. Show
TDD for Embedded C Excellent A new way to look at problems that I had not considered before. Good balance Good balance More conceptual explanation of what spies, mocks, and fakes are before doing exercises. I get the general idea, but still not quite sure what the differences are and how each one works. I felt as if I was going in blind to some of the exercises. Very Good More conceptual explanation beforehand. Good speaker, very knowledgeable. I'd like to see your Dad's gun camera footage! Much better Currently working on a relatively small C# project for internal use where the consequences of defects are very low. Not sure the learning curve is worth it at this time. Not many, other than the learning curve. We have management buy-in at least for embedded firmware. Show
TDD for Embedded C Very Good Principles and application of TDD to projects the engineering team works on. Not enough exercises Good balance Have the team work on a larger (multi-part) exercise. Excellent Use the exercise to drive discussion/training more directly. Much better Yes Multisited team, large project, internal leadership challenges Show
TDD for Embedded C Very Good Good balance Good balance Good Moderately Show
Test-Driven Development very good Good balance Good Instructor... Kept the class engaged. Bring it on! Yes... I now have the competency in CPPUTest to use it. Show
Test-Driven Development good Good balance Reduce reliance on language knowledge. Clear and seems to be in command of the subject matter. Much better yes; I am better prepared Show
Test-Driven Development excellent Good balance Very instructive with a logical increase in the level of complexity that helps the student to improve Very Knowledgeable. Very good way to convey the knowledge in a fun way. Very patient and helpful. Moderately Not tomorrow but soon. I need a little more of practice by building up in code that already contains TDD and Unit Test in them. Show
Test-Driven Development very good Good balance The course introduced me to CPPUtest and gave me insight into how to work with existing code. Excellent delivery and explanation of concepts Moderately yes Show
Test-Driven Development very good Good balance The use of Cyber Dojo was enjoyable. James is a skilled instructor and was a pleasure to learn from. Much better Yes; I could; but tomorrow is Saturday; so I probably won't. I will continue with this on Monday; though. Show
Test-Driven Development excellent Good balance Much better cause tommorrow is sat. Show
Test-Driven Development very good Good balance Much better yes Show
Test-Driven Development very good Good balance The exercises did give me an understanding of the concepts very well. Excellent! Much better Yes Show
Test-Driven Development good Good balance Much better yes Show
Test-Driven Development very good Good balance Limit pairing to 2 people instead of 3 or 4. Great job keeping it interesting!! Software concepts can be redundant and hence boring sometimes. Much better During the next development assignment. But feel ready to apply some TDD techniques from tomorrow. Show
Test-Driven Development very good Good balance I thought too much time was spent in the refactoring exercise (changing variable names) Nice blend of seriousness and light-hearted comedy. Good at expressing ideas in an easy to understand way. Bring it on! Probably not since I am not currently working on a coding project Show
Test-Driven Development very good Good balance Moderately Show
Test-Driven Development very good Good balance Moderately Show
Test-Driven Development very good Good balance Very good for figuring out how to effectively use TDD. Very helpful; and also very blunt. Much better I cannot; we need to do all of our legacy code testing fisrt before we can TDD new functionality because this functionality is added to the legacy code. Show
Test-Driven Development very good Good balance Covered all important topics Clear; helpful Much better Yes; well not tomorrow...it's Saturday Show
Test-Driven Development excellent Good balance Bring it on! Yes. Show
Test-Driven Development very good Good balance Well designed to lead us through the concepts. James did a good job explaining the concepts. Moderately Probably not. Dsp has a lot of tests that are reading and writing long input vectors/output vectors. We are still thinking about how we can apply TDD to this. Show
Test-Driven Development excellent Good balance The sample application ideas were easy to grasp and made it easy to jump in and start trying out the TDD approach. Excellent instructor. I really liked this class and the instructor - definitely one of the best I've ever had. Great interaction with the class. He did a great job of keeping the class on track; which can be really challenging with an intact team that can have the tendency to take the discussion on tangents. Bring it on! Probably not. My code has such a large number of dependencies that stand-alone development of a single class will be challenging. As I have opportunity; I hope to apply this approach in extracting functionality into new small classes. Show
Test-Driven Development Good balance N/A Show
Test-Driven Development very good Good balance James was very helpful in explaining the key concepts and provided very useful suggestions to solve few issues that pertained to our code. Much better I feel we can use the UT concepts immediately on our existing code. for TDD to be useful; we need to refactor our code to smaller classes and reduce build time. Show
Test-Driven Development excellent Good balance Instructor has an excellent method to relate to the audience and is very engaging. Bring it on! I have already started. Show
Test-Driven Development very good Good balance Displayed great knowledge of his craft and willingness to answer questions even if they are sometimes off topic. Bring it on! I could start today; however because of system complexity it will be a slow ramp up process. Show
Test-Driven Development very good Good balance Displayed great knowledge of his craft and willingness to answer questions even if they are sometimes off topic. Bring it on! I could start today; however because of system complexity it will be a slow ramp up process. Show
Test-Driven Development very good Good balance The exercises were thought provoking and kept the interest going till the end of the class. James was ready to answer all the questions; and helped us all the time to get the testing working for the production code. Much better yes. With the instructor's hands-on training approach in the class; I am very well prepared to apply it right now which I am doing this afternoon right after the class. Show
Test-Driven Development very good Good balance I wouldn't have minded having some more exercises that practiced the writing of tests. Bring it on! No; I had an issue of not installing cygwin correctly. The header includes on my real work is rather large too. Show
Test-Driven Development excellent Good balance The examples were great in reinforcing newly learned concepts. I really like the refactoring group programming exercise. However; I think we spent a little too much time on renaming all the variables. We could've renamed the first couple variables; inserted a comment to re-examine all variable/function names at a later time; and moved on to other code smells. Great job! I really liked the real-world examples (or stories) given; though past industry experience; while teaching us these new concepts and how they can assist us to better our craft. Much better At this point; I feel comfortable that I could start tomorrow. However; the ability to consult a TDD expert; as needed; would be of great assistance. Show
Test-Driven Development good Good balance Moderately Yes; already started with current project. Show
Test-Driven Development excellent Good balance Needed pair programming so that what needed to be done was discussed; otherwise without talking about it I think the exercises would have been hard to figure out. Unflustered while topic was be challenged. I respect that and helps me believe TDD is worthwhile. Much better Yes; but I am in post release support group so I need to adapt what is already there. It would be nice to help identify target code for refactoring and be involved with doing that as work load permits. Show
Test-Driven Development very good Good balance I liked the code dojo web interface very much. I liked the balanced approach to different design choices. Much better Not immediately tomorrow. This will be more of a gradual transition from highly coupled code to reduce risk of introducing defects. Show
Test-Driven Development excellent Good balance My favorite exercise was the Circular Buffer. Did a great job at introducing TDD. Made the topic interesting and applicable to using TDD in C++. Bring it on! No because we are in the process of upmerging. I hope we can use it in future development. Show
Test-Driven Development fair Good balance A little started ago Show
Test-Driven Development very good Good balance I enjoyed working on the exercises; being able to have small wins and incremental test/code development. I like the pace and the presentation style. The instructor was very helpful and easy to approach. Moderately Yes; but initial setup of the project would be necessary Show
Test-Driven Development very good Good balance Moderately If i was starting something completely new; then yes. There is still lots of test framework to build for our legacy code. Show
Test-Driven Development good Good balance Good examples; but the codes were given to facilitate the test development. Moderately Started 5 years ago. Show
Test-Driven Development excellent Good balance Much better YES Show
Test-Driven Development very good Good balance I like the exercises and environment; but felt they targeted more of learning c++ than learning TDD. Very good class. I was entertained and feel I learned enough to continue alone. Much better Yes Show
Test-Driven Development very good Good balance When I was a bit lost I could just check the text of the published book (vs the class ppt). However I can't decide if that was good or bad. I always got right back on track and completed the exercises (which felt good). But I was also just copying from the book (so I'm not sure how much I was learning). Overall I'm still going with Good! James and Bob were both excellent. Thank you both for coming to Louisville. Much better I can start as soon as I actually get to a PC for technical work. (Meetings; JIRAing; etc don't count (that is; I don't actually get the chance to work on code everyday (but sure wish I did))). Show
Test-Driven Development excellent Good balance None - they're relevant and typical. Very good. Enthusiastic about TDD; but grounded in reality: mentioned that some things just aren't the best target for TDD. Much better Yes; I could start tomorrow. I now know enough to be really dangerous. I think I could start with something easy and work my way to proficiency. Show
Test-Driven Development very good Good balance FFF and getting the refactoring project running in my VM were a challenge. Great instructors. Obviously experts and spoke my language; such that I stayed engaged. Bring it on! No.The logistics of environment setup will cause a delay - slow pc to run VM/Eclipse;learning new environment and project setup.Working with GE team to get me up to speed. Show
Test-Driven Development Good balance Show
Test-Driven Development excellent Good balance They start simple and build in scope and effort. It allows you to build on the knowledge as you are learning it. OUTSTANDING! Was able to cover the material in a way that it was easy to understand and devoted extra time to help with any questions. Much better Yes; but on a part-time basis. I am going to be pushing it into a module that has already been written. Show
Test-Driven Development excellent Good balance A+ Much better I started a while back actually. Show
Test-Driven Development very good Good balance I particulary liked the refactoring exercise and the lights service exercise. But I would have loved to have more time to deal with legacy code. Good teacher; knows how to explain what he wants to say; funny wich makes the course enjoyable and better to understand. Bring it on! No; I can start in January. The honest answer; because my boss wants to start then. So maybe I can start practicing on my own outside work. Show
Test-Driven Development very good Good balance I particulary liked the refactoring exercise and the lights service exercise. But I would have loved to have more time to deal with legacy code. Good teacher; knows how to explain what he wants to say; funny wich makes the course enjoyable and better to understand. Bring it on! No; I can start in January. The honest answer; because my boss wants to start then. So maybe I can start practicing on my own outside work. Show
Test-Driven Development excellent Good balance Moderately Show
Test-Driven Development very good Good balance Much better I will start trying to do this monday morning Show
Test-Driven Development excellent Good balance Best instructor thus far. Bring it on! No; it's Saturday :) Otherwise yes; but we need to start with a meeting to develop a plan. Show
Test-Driven Development very good Good balance Course exercises illustrate fundamental concepts; which is what they are designed for. Extra effort is needed to apply concepts to more complex code. Very knowledgeable. Presented clear and concise arguments for the benefits of TDD. Moderately Yes. I can identify some new features that could benefit from unit testing. Show
Test-Driven Development good Good balance Well chosen A little No; its the weekend. After that its clear sailing Show
Test-Driven Development very good Good balance Excellent Much better No; it's the weekend ;-) Monday i will be starting to apply TDD principles. Show
Test-Driven Development very good Good balance The exercises were good; but we definitely required guidance and walk-through. (in particular with the FFF module) through some of the exercises. Perhaps the exercises need to be broken down into accomplishing simple tasks first; and incrementally introduce new ideas? (like done with the mock; but from the fff; just have an exercise that requires only fake functions; not special calls to functions we did not learn about...) Instructing was done very well. A little I can start; but with some initial difficulty getting the harness in the code. Show
Test-Driven Development very good Good balance They were well documented and getting the environment up wasnt too painful. A little Probably not. But that is my fault - i missed the first 2 days of training. Show
Test-Driven Development very good Good balance Good preparation; presentation skills combined with a depth of knowledge. Much better Next time I do development; I might use it for unit testing instead of throw away stubs. Show
Test-Driven Development excellent Good balance Bring it on! Yes. Clear understanding of how to; at least; start using stories and TDD. Show
Test-Driven Development very good Good balance -excellent instructor -great wealth of knowledge and experience Much better Yes. I'm looking forward to attempting to embedded cpputest into our target. Show
Test-Driven Development excellent Good balance Good presentation of material. Excellent; compelling; relevant anecdotes. Obviously a wealth of experience. Moderately No. It's Saturday. But seriously; yes. Show
Test-Driven Development excellent Good balance If we had more time to do the exercises fully; that would solidify understanding. Much better Have started already. Show
Test-Driven Development excellent Good balance Very nice:) Great! Bring it on! I am working on that right now... I have finished porting CppUtest to QNX OS and integrating it in to our projects.... Show
Test-Driven Development good Good balance The exercises were excellent. However; I wish we could choose to work individually if we wanted to. The pairing system didn't work for me. I often found that the other person would take control and it was very hard for me to follow. I would have gotten a lot more out of the exercises if I could do them myself. Much better Yes. Because I believe I understand the concept of TDD as a result of taking this course. Therefore; I am able to use the techniques that I learned in my own projects. Show
Test-Driven Development excellent Good balance Excercises were great for introducing anyone to the TDD method. Very knowledgable in TDD and agile practices. Much better Yes; we have common TDD environment and template setup for our group. Anyone can start writing test cases very easily. Show
Test-Driven Development very good Good balance I liked the cyber-dojo setup; pairing had its pluses and minuses. I got paired with good people; yet I saw some pairs that were counterproductive. Good job! Much better Yeah; I have the framework in place and think I have gotten past the ramp up portion. Show
Test-Driven Development very good Good balance Knowledgable; approachable; answered questions thoroughly; actively sought feedback from class on current issues/concerns Much better Yes; in fact; implement >50 UT's on a legacy app Show
Test-Driven Development Good balance Practical implmentations will definitely help me in approaching bigger problems in future. Much better It could be started depending on the size & deadline of project. Show
Test-Driven Development very good Good balance Very clear explanation of material and a lot of practical help. Moderately Not yet; need more exercising Show
Test-Driven Development very good Good balance Much better Good to go. Show
Test-Driven Development very good Good balance Interesting exercises; perhaps increased in size a bit too quickly. Smaller; trickier exercises might be interesting. "Lacks some tact/cultural sensitivity; especially w/r/t ""oriental"" comments; mocking of Chinese writing." Moderately Yes. Show
Test-Driven Development excellent Good balance The last 2 days when we were setting up UT projects for different areas of legacy code; most of the issues were just to get a basic UT compiling and linking; I think we can do that outside of the class (before hand) and focus more on the problems we have when creating test cases how to make them easy to maintain and hard to break with small code changes/refactoring. Much better Yes I can. Show
Test-Driven Development very good good balance Good balance very good N/A Excellent tips on how to cleanup our legacy code Moderately No. Our build is too slow Out dependencies are out of control. We are attempting to fix these first before doing TDD. We are doing TAD now with CPP U Test -People not designing everything up front -Please writing all the code up front -Please being afraid that UT test cases can be considered documentation Show
Test-Driven Development excellent good balance Good balance excellent Very patient with people and willing to listen. Bring it on! already on the way The current state of our code. Show
Test-Driven Development excellent good balance Good balance very good Instructions needs to be more clear Very good Much better yes Time Show
Test-Driven Development good good balance Good balance good Very knowlegeable Moderately Mind set change. Not that it can't be done and I'm all for change but this is a radical change from how we've done things so it's kind of like having to re-wire the brain to think in a new way. Show
Test-Driven Development good too many exercises Good balance good Major concepts were not covered in the course exercises. Instructor is knowledgeable. Needs to improve on the Cyber-Dojo setup for the class. Much better Yes; already tried on some legacy code. If there are large amount of legacy code; rewriting the unit test for them is prohibitive. Show
Test-Driven Development excellent good balance Good balance very good I would have liked to see some more advanced exercises. I was hoping to get more insight into industry practices regarding TDD that you have gathered through your experience. I was particularly looking for some encouraging news on any companies that may have made strides in converting legacy software to TDD. I understand that you probably have strict limits on what info you can share due to agreements with others. Overall; I enjoyed the class as well as your previous visit; they were both very useful in re-enforcing many gut feelings I and others have collected over the years; about things we may be doing wrong. Moderately I am starting with a personal (non-work) project. At work; we are formulating a header cleanup strategy to help us get going a bit easier. Untangling all the coupling we have between components. Show
Test-Driven Development very good good balance Good balance good Exercises should focus more on utilizing more of the CppUtest and Mocking capabilities. Overall; the course was well planned and presented. Much better Yes. The hands-on exercises helped a lot. Legacy software has a lot of dependencies. It will be hard to bring the code into a test harness. Show
Test-Driven Development very good good balance Good balance very good I think the course exercises were very helpful and provided good hands on examples. Enjoyed the interactive nature of the course. Much better Yes Initial time investment to get components at a point where we can start using TDD Show
Test-Driven Development very good good balance Good balance good Moderately Yes. Not easy to write tests for legacy code. Show
Test-Driven Development excellent good balance Good balance very good Bring it on! I probably could start tomorrow; but it may be better to wait 1-2 weeks until this release is done and then start TDD within a month. There is quite a bit of legacy code Show
Test-Driven Development excellent good balance Good balance excellent Being an embedded programmer up to now; I really like the flash example. The other examples were good as well; such as the Light Scheduler. James did a great job imparting his years of experience to our group. He's obviously been in our shoes and has done this many times. Bring it on! Yes; I will use it to test out my ConfigData class I'll be moving over from System One to possible use in SiteIQ for the registry. I figure I'll move it over and get it in a test fixture. Tackling large; tightly coupled systems. Show
Test-Driven Development excellent good balance Good balance good Much better Yes. We are better equipped mentally and with the right mindset to do TDD. Natural developer urge to solve the problem rather than Show
Test-Driven Development excellent good balance Good balance very good I liked the zero setup time and also the examples. Only the mocking example could have been explained a bit more before executing the work but I think that we chose the wrong sample code very well to understand Bring it on! No. We are facing system test shortly. Legacy code Show
Test-Driven Development excellent good balance Good balance very good I haven't written any meaningful code since 1991 and I was still able to follow along as the exercises started and then being able to take over when pairing. Patient. Clear. Good listener. Cares if you're getting it or not. Looks to make sure everyone gets it. Much better I probably won't do a lot of it but will be helping were I can and helping to drive its adoption. We're much more prepared to do this now. Continuing to do what we've learned in our training. The tendency to fall back on old ways it going to be hard for some to resist. Show
Test-Driven Development excellent good balance Good balance good Much better I can and I will. Now I know how much I can improve the quality of my code by starting soon; singleton structures; OS or API dependencies Show
Test-Driven Development excellent good balance Good balance very good Well done-- seemed to connect well to the engineers. Much better Yes Discipline to use it enough to become comfortable with the techique Show
Test-Driven Development excellent good balance Good balance very good Some were way too long to finish before the end of the day. Instuctor was very good at explaining the concepts; answering questions; and helping with the exercises and also during hands-on workshop sessions. Bring it on! No; current work does not involve code development or testing. Applying TDD to higher-level programming environment such as Matlab. Show
Test-Driven Development very good good balance Good balance good Perhaps it might be good to dedicate some time to how the frameworks and compilers work in the background. This would've helped in understanding what was going on when I was setting up my code in the last 2 days. GREAT Moderately Yes Getting started and using the frameworks Show
Test-Driven Development very good good balance Good balance very good The course exercises chose simple and useful problems (E.g. the circular FIFO; the light controller) He was friendly; polite; and professional. He was also accommodative of personal issues. Much better Yes; I already wrote unit tests with the gtest/gmock framework during the training workshop Much of the code I work on is already written; and TDD wasn't applied. We are developing enhancements. TDD will be much easier applied when it is included from the very beginning of development. Show
Test-Driven Development excellent good balance Good balance very good It seemed like the latter exercises were more about different types of fakes. It think these exercises would have been better if the fake was not already implemented. Maybe an exercise in taking a source file with a standard Fx and converting it to a Fx* and managing the init/override would have helped more. Bring it on! Yes! My project is in the latter stages of requirements development so it is a great time to get development environments set up and get started writing some TDD code. My organization has typically written assembly-level; over-optimized code. As such; many of the best-practices in SW engineering are not employed. Some C is written but typically within the confines of on-target compilation and manual testing. Show
Test-Driven Development very good too many exercises Good balance fair Maybe I am not in the field of embedded C. So it takes time for me to understand the objective. Good instructor Much better I want to start tomorrow. Get used to it. Do not go back even it is fast. Show
Test-Driven Development good good balance Good balance fair My background is chemical engineering. I required more explanation on the exercises. For example; I heard about CircularBuffer in this course for the first time. Also; the Flash Program required more explanation as I was not familiar with the inputs and outputs of the flowchart. However; I did learn about those exercise during the exercise from peers. The instructor is very knowledgeable and intelligent. He handled the questions very well. He has good experience on this subject and a good teacher. Although the PowerPoint slides were clear; time spent on explaining the slides was not sufficient. Much better I always work with legacy code. It might take some time for me to apply TDD to test the developed code. However; I will apply TDD in any of my future developments. a) I work with FORTRAN. This course was based on C/C++. Hence; it was difficult for me to relate the instructions and TDD procedure to my work. b)Setting up the enironmental variables and the compiler options were challenging. Show
Test-Driven Development very good good balance Good balance very good It would be helpful if the code-dojo was aware that multiple computers were watching it and they got updated. This would augment paired programming and facilitate secondary screens. Alternatively; multiple open windows would also work so that one was not switching between windows constantly. Switching windows interrupts context and concentration. Bring it on! yes. I have an immediate need to create some new code for a new but well understood function. interrupting the brain flow. I like to sit in the editor and create/refactor/iterate without going to the compiler. I tend to pull out and go back to diagrams as part of the process. I anticipate the extra interrupts of compiling/testing/fixing clashing with my developed work habits. Show
Test-Driven Development very good good balance Good balance very good Good pace. Conveyed concepts effectively. Bring it on! Yes. Already started. Applying the principles correctly and efficiently. Show
Test-Driven Development excellent good balance Good balance excellent Very good exercises. The use of cyber-dojo made it real easy to work on the exercises. Very knowledgeable; and did a great job selling the importance of TDD. Much better Yes; probably need a little more practice but definitely learned enough to get started.. Convincing management that the extra up front time required will better benefit the project. Show
Test-Driven Development excellent good balance Good balance very good "Exercises were a bit tricky for novices or those unfamiliar with C; perhaps there is an easier ""entry point""" Very helpful; explained things well and patiently; could tell when the students were struggling with ideas and address that quickly. Bring it on! I'm not typically a coder at work; but I will be applying it immediately for my hobby work We're pretty open minded to TDD; but the challenges are going to be applying it in multiplatform projects that have different OSs in the same project; and managing the different packages; etc. Show
Test-Driven Development excellent good balance Good balance excellent I think the cyber dojo is very good because anyone can start TDD at a full spead from the 1st day. I love it! Many hands-on helped us learn by ourselves. And Q&A sessions were great because James-san answered for all questions. Thanks a lot! Bring it on! Yes; of course! I'd like to change manual testing & release that take around 1 day. I introduced automatic build & deploy with Jenkins. The next theme is TDD. A lack of skills & slack. I'll make a slack with TDD. Show
Test-Driven Development excellent good balance Good balance excellent "Excercises was so excite for me. I felt ""cyber-dojo"" system; prepared exercises code and James's introduction was so excellent." thank you for replying many our questions. Much better I want to try it. But I afraild our colleage and boss who doesn't know/undetstand the effect of TDD. Because they afraid to change code; i think. breaking Dependency; and obtaining coworker's understanding. Show
Test-Driven Development excellent not enough exercises Good balance good Thank you for instruct me about technique of TDD; and mind. I re-recognize that silver bullet doesn't exist. I'll improve our code little by little. Much better Yes. This is big challenge for me; but at first; I co-operate with my chief about separate dependency. Complicated dependency. I would solve this huge issue. Show
Test-Driven Development very good good balance Good balance excellent I found fun of TDD exercises. Instructor answers questions very well. Much better I will set up tools?tomorrow. Development in a period shorter than now. Show
Test-Driven Development excellent good balance Good balance excellent Thank you for answering each question carefully! It was able to be understood very well. Much better Yes. I intend to apply to an experimental project. Really applying it about fake; spy and mock (choosing appropriate technique) Show
Test-Driven Development good good balance Good balance good There was a practice at a loss to what to do. There was a place where answers to questions are hard to understand. Moderately Does not yet begun the implementation phase. Be to understand an overview of the TDD in the people around. Show
Test-Driven Development very good good balance Good balance good Good. But I want to get more long time. Very good. Much better I don't coding now. huge legacy code Show
Test-Driven Development very good good balance Good balance very good It was very convenient for us to use your Cyber-Dojo site to do coding and testing it. Good. Much better Yes I can start. we have already used CI with Jenkins. So just consider to build our C/C++ code with Jenkins for testing. How to get involved other team which are using C/C++ code. Show
Test-Driven Development excellent good balance Good balance excellent Excellent. practice and logic can be taken at the same time in the course. good! Much better yes not sure how much our work can be calm. Now i believe TDD should work. However; most challenge could be influencing this experience to other developers in company. Show
Test-Driven Development very good good balance Good balance good feels little bit hard Much better I start to improve my TDD course! to teach embedded persons Show
Test-Driven Development very good good balance Good balance very good Good Good Moderately Yes because it is powerful and useful. No big challenges. Luckily my current boss does not care about the details or method; but he only cares about the outputs. I think I can provide the outputs at higher quality more easily with TDD and unit tests than before. Show
Test-Driven Development excellent good balance Good balance excellent They are well-thought. I could get help from the course note when I was stuck. It avoid me to give up. Very good. Very patient and we can feel that you're trying to understand what we try to do Much better No... because I am working on fortran code. I found a test unit for fortan working on Unix. It will take me a while to get it work on windows environment. I have to deal with huge data; but you show me how I can fake them. Show
Test-Driven Development good good balance Good balance good System was very nice. Moderately I will start next week; because I was requested to complete my being developed code as soon as possible. My manager do not care about TDD; and I do not have time to explain the importance of TDD to him. How to allocate time for TDD when I need to release software by tomorrow. Show
Test-Driven Development very good good balance Good balance good The exercises you provide were simple and easy to understand; but there is a big gap between the exercises and applying TDD to my code. So it might be good to give detail instruction about applying TDD to existing complicated code It was really nice for me that you sit beside me and solve errors one by one together. It was really learnable for me. Much better Yes. Now I have test environment; have idea of how to make test cases and mocks; and I have a DSP code which is not tested yet. I can start tomorrow. Actually now I use Visual DSP and LabWindows to develop my software. So it takes much time to apply Visual Studio TDD for my codes. Show
Test-Driven Development excellent good balance Good balance excellent Course materials on Web is the best for me because I can use my PC and the materials are prepared very well. Rate of the exercise is also pretty good. I think it is better to do things actually than just learning on the desk. I think you have all about embedded development so I learned practical things depends on your experience. Bring it on! Yes. I have already introduced TDD to my development. I had challenge in applying TDD which is to obtain time for TDD from time to develop production code. I had to develop production code quickly so I couldn't prepare much time for TDD. Show
Test-Driven Development excellent good balance Good balance very good Exercises using cyber dojo was excellent. We could work on the same environment and could learn the basics of TDD effectively. Thank you very much for providing excellent training. I learned a lot. Bring it on! Yes. The test environment is ready to go. Can start even today. We may need to change the structure of legacy codes . Show
Test-Driven Development very good good balance Good balance very good Pair programming worked fine good knowledge and helpful Moderately yes to remove complex class dependencies Show
Test-Driven Development good good balance Good balance good Not at all Not yet. I cannot make my environment worked for me and I even did not do any test on my legacy code yet. make my code linked with each other Show
Test-Driven Development very good good balance Good balance good I enjoyed exercise; interesting example and I could consult in pair group. Presentation is easy to understand because of pictures. Moderately Now I have no work to code. But in next work I will try to apply it. Remove dependency from target class is very difficult. Up to target classes I think I have to find other way. Show
Test-Driven Development very good good balance Good balance good Excerise was fun! Very good! Much better Not tomorrow; because alpha test will start next week and beta test starts in 3 weeks. But we will start creating unit test after that. One of the difficulty to apply TDD is tight schedule of our product release. So; the major challenge is to find out the right timing to apply. Show
Test-Driven Development excellent good balance Good balance excellent It was great to have lot of freedom and actually start applying TDD to problems we have in work. I really liked the instructor. Cool; relaxed attitude. Not pushy but always prepared to help. Bring it on! Yes; even set the environment that can be used for whole project. Most of our work at this moment is integration type (i.e.; computation DLLs into framework + visualization). Using TDD is not so straightforward here... But can be done! Show
Test-Driven Development excellent good balance Good balance good I think I had a good understanding of the concept of the exercises. It was good to do pair programming since I could get good ideas from other people since I'm a S/W begginer (1 year experience). It was fun; thank you. Much better Yes. My code is not using SLB framework; but only MS. So I didn't find it that difficult to use the test harnes. To get used to the way of thinking. Also; I need to make sure if I don't have any license issue. Show
Test-Driven Development very good good balance Good balance very good Moderately a list of high priority tasks need to be resolved first. My work involves mostly with hardware interaction. Show
Test-Driven Development excellent not enough exercises Good balance excellent great instructor. Very helpful in the learning process. Moderately yes. in the exercises for the last two days; I have already setup the TDD framework for the current code base my team is working on. We can start the TDD approach next monday. If we start a new project; applying TDD is a lot simpler. But with existing project; I can see more challenges. Luckily; in our organization; our project cycle is short and usually we start fresh. so i guess we don't get challenged that much that often. Show
Test-Driven Development excellent good balance Good balance very good Pair programming worked well. Swapping partners also worked well. Great use of post-its to gather feedback instead of relying on people to raise their hands. Much better No; but I'll certainly work on getting management buy-in. Bosses aren't proactive. They are always more concerned with adding new features than with minimizing test and debug time. Getting management buy-in seems even more challenging than tackling pieces of the massive legacy codebase. Show
Test-Driven Development very good good balance Good balance very good reasonable; easy to see how they apply to my work. Good Much better too busy; I am now 2 weeks behind the near total change in approach. Plus company requirements to make next release. Show
Test-Driven Development excellent good balance Good balance excellent Excellent Excellent Bring it on! Yes compiling; refactor legacy code Show
Test-Driven Development very good good balance Good balance good The exercises are good. James gives a good presentation of TDD. Much better Will be starting on Monday. :) The tendency of organizations to resist changes they do not understand. Show
Test-Driven Development excellent good balance Good balance excellent Would like it to be easier to take my final exercise source files for later reference. Very knowledgeable and highly recommended. Bring it on! Yes; we have a significant amount of code which is hard to understand and the process of refactoring it would improve it for all users. Breaking the dependencies is going to be a significant development effort. Show
Test-Driven Development good good balance Good balance good A little "No. The knowledge gained from this class is to be used in the next month or so when the next project requires the use of ""C""." Always getting management to understand the ramp up required as probably 95% of engineering is new to this TDD concept. Management doesn't have any idea about TDD and what it is involved. Show
Test-Driven Development very good good balance Good balance good Some of the instruction are a bit confusing. But the instructor is helpful. Much better Yes I can apply TDD to my coding style and the code I touch. But with the entire codebase; I don't think I can get to all of it with the allocated amount of time. Trying to refactor the existing code that is in a very tangled state. Show
Test-Driven Development excellent good balance Good balance excellent Great job! Much better Yes. Need to convince other team members to work on this concept - they need the course too! Show
Test-Driven Development very good not enough exercises Good balance good Much better Yes Allowed to check in code. Show
Test-Driven Development good not enough exercises Good balance very good instructive. like your illistrative slides. Moderately GOing to try. Have some modifications to legacy code that I would like to try this on. Lots of the legacy depdencies might make it hard to test. Show
Test-Driven Development very good good balance Good balance excellent It was very good to get practical knowledge. The exmples were simple enough to focus on the essence. The use of the Code Dojo is great as it takes tool and installation problems out of the exercise time. Good point and well able to take issues and have discussion as it comes up Bring it on! Yes. As soon as I get the tools up running I will be fine. (or using CPPUNIT as we have allready in place) Fright that my progress implementing will seem too slow because a lot of the testing will be done along the way. (How to make it visible that debug time is reduced) Show
Test-Driven Development excellent good balance Good balance excellent They were very helpfull to understand TDD. For me it's always so good to learn from someone who really believes and apply what he is talking about. Much better Yes I absolutely can and I will. Being able to justify the way that it will take to master it. Show
Test-Driven Development Good balance N/A Show
Test-Driven Development Good balance N/A Show
Test-Driven Development excellent good balance Good balance excellent The exercises were very helpful in understanding the concepts. Excellent instructor. Much better Most of my work is on legacy code; so changes will be very incremental (and slow to happen). Show
Test-Driven Development very good good balance Good balance good The online coding environment was really neat. The exercises were good. I think you did a great job; given the weird multi-site setup we had. I wish it had been 100% local. I think that slowed things down a lot. I felt like we could have covered a lot more ground. But it is what it is. Much better No - but only because my current role is not coding. I'll actually be doing python soon; and we'll be doing TDD there. Convincing the development team that it's valuable and to give it a real chance. Show
Test-Driven Development excellent good balance Good balance excellent Much better yes Great for unit test of individual units. Still sees challenges for system level tests. Show
Test-Driven Development very good good balance Good balance good Knowledgeable; applies just the right amount of theory and application with programming examples. Thank you for providing the cyber-dojo training application! Much better Yes; but may take a little while to actually gain momentum given that I'm already firefighting with EFT customer issues all over the place. "competing ""higher priority"" customer issues which eats up a lot of my work hours. Managers having to get used to the longer lead time for development." Show
Test-Driven Development Good balance The exercise is well prepared and the zip file is very useful. N/A Show
Test-Driven Development very good good balance Good balance very good I like the exercises start from easy to more difficult; and you can modify the program step by step and see the results right away. The lectures are clear; but sometimes the slides switch/jump around. Much better I can start to test the small modules soon. TDD is a good tools for the automatic tests. To cut the interdependency among modules and fake the dependency functions. Show
Test-Driven Development excellent good balance Good balance very good awesome! thanks. awesome! thanks. Much better Still; it is hard to work with legacy code. mocking/faking legacy code Show
Test-Driven Development excellent good balance Good balance excellent please share... excellent example! Moderately yes; I can. it was useful for me. legacy code testing Show
Test-Driven Development excellent good balance Good balance excellent the course exercises were all nicely organized to help us understanding TDD and the cyber-dojo development environment was very simple and easy to use for students Thank you very much for your teaching. I was able to learn much more that I expected. Bring it on! Yes Show
Test-Driven Development very good good balance Good balance very good Good. Good exercise code. Good. I want to be like you. Much better I'm already using TDD. I feel I need more exercise. Small step. Big step breaks TDD. Show
Test-Driven Development excellent good balance Good balance very good User Scenario was not fixed at the first time; so we came to get it through work. If we can get some hints about what happens next. For example; I was embarrassed when I came to know I have to handle wrong schedule; on schedule and off schedule at the same time. Much better Yes. I do. Different build environment - kernel build cannot use glib; also cannot include etcs... Show
Test-Driven Development very good good balance Good balance very good to change a partner is a chance to read other members's code Much better I start to read the TDD book. to make test cases Show
Test-Driven Development excellent good balance Good balance good It was too easy. i could easily do with that example. because it's easy to find starting point. (it means course exercises were good to understand basic concept of TDD.) Couldn't be better. Much better Yeah; but it's little bit hard to know how can i start or where is the starting point. Applying to the legacy code. I can't see the running test case yet!!! Show
Test-Driven Development excellent not enough exercises Good balance excellent Nice. I will practice it over and over again. Thank you Mr. Grenning. Your guidance cleared lots of mist in front of my eyesight. Much better Yes. Because I learned how to start? My poor skill at TDD? Show
Test-Driven Development excellent good balance Good balance very good Good. Excellent. Much better TDD is very useful; so I will try to apply it in my work. In huge system; there are still remained several challenges about that. Show
Test-Driven Development very good good balance Good balance very good valuable time to learn how to start TDD passion many experiences Moderately no. Because a lot of things to do. legacy code. developement skills Show
Test-Driven Development excellent good balance Good balance excellent They where at the correct complexity for the course duration. Very knowledgeable. probably the most knwoledgeable on TDD. Did not promote TDD as the answer to every problem. Bring it on! No. Already started :) Minor changes to public interfaces breaking a lot of tests and create LOTS of rework. Show
Test-Driven Development very good good balance Good balance very good Exercises could have been a little more organized. At times I felt there were too many moving parts because the framework itself needed some tweaks frequently No doubt one of the best instructors I have come across..An authority on the subject Much better Yes I can It requires change in mindset for the entire organization. Nut we can certainly start small and demonstrate the success Show
Test-Driven Development excellent not enough exercises Good balance excellent Aimed at just the right level; I found them relevant and challenging. The platform independent browser environment is an excellent idea. Great stuff; clearly very interested in his subject; and very well informed. Enthusiasm for TDD is infectious; enough to convince the most hardline sceptic! Much better Not immediately; as there are too many pressures at work to get to the next milestone. Finding time to experiment with the Testing and Mocking frameworks. To get enough experience I'm going to need to play around with them in my free time. That's something I'd like to do. Show
Test-Driven Development excellent good balance Good balance very good They were good. Sometimes I thought I already knew what I was doing but having James look over our shoulders exposed a lot of weak areas that we weren't even aware of. Patient and positive. Much better Yes. I have been working with TDD when extending and debugging existing code. Existing code is not testable. I expect that using TDD from the start drives code to be more testable. Show
Test-Driven Development very good good balance Good balance very good Well designed and well rehearsed. We had a lot of topics to cover in a short period of time and you did a great job of keeping things on track. Bring it on! I have already started to move tests into legacy code. Getting the rest of the developers to apply TDD. Show
Test-Driven Development excellent good balance Good balance very good Much better I can start immediately but have to set up the infrastructure first in order to make TDD possible also for colleagues. Integration into the existing build environment. Show
Test-Driven Development excellent good balance Good balance very good Much better Not tomorrow; but hopefully soon! Getting other programmers and management to buy in. Show
Test-Driven Development very good good balance Good balance good I think that having an example using a common hardware driver and spoof would be helpful. Something like an ADC or UART. I thought that James was patient and able to explain the material well. I found the real world examples the most helpful. Much better I can start getting existing code into a test framework. I still have to convince my co-workers that this method is worth the overhead. Hardware dependencies and compiling tests for a different target. Strategies for both were presented in the class. Show
Test-Driven Development excellent good balance Good balance very good I thought James' understanding and experience with the material were excellent. He was always able to call up real examples to illustrate his points. Also; he was able to handle questions in ways that showed he not only understood the questions but also understood the answers. Much better Yes and no. I have the tools to do it myself; but rolling it out to the rest of the group in an appropriate manner will take some time. 1. Applying it to our mountain of legacy code. 2. Change is hard. I will need to present it to the team in a way that resonates with them in the same way that it resonates with me in order to get them on board. Show
Test-Driven Development good good balance Good balance good A little Large legacy code base Show
Test-Driven Development very good good balance Good balance very good good examples; to the point good pace; knowledgeable; good balance Much better yes schedule dates; as the initial deployment of TDD will require initial time to be invested Show
Test-Driven Development very good good balance Good balance good I liked most of them. I liked the way the course was structured and presented. Moderately Yes in theory. However keeping in mind tight deadlines in the existing schedules; huge amount of legacy code and some learning necessary to start using TDD effectively I won't be able to start tomorrow. However I'll try to apply TDD concepts to newly developed code - Tight schedules - Huge amount of legacy code with new changes done on top of legacy code rather than completely new development. - Quite a lot of learning necessary to start using TDD effectively Show
Test-Driven Development very good good balance Good balance very good - refactoring and FFF is good exercises. - never need to use debugger!! - Fun guy!! - A good mentor also. Much better Already started; but its weekend tomorrow; I will wait for Monday :) - to get everyone addicted Show
Test-Driven Development excellent good balance Good balance excellent well arranged course; it is practical sample to help real work very knowledgeable for the course. interactive. Much better Yes; i will start on small portion of code we have larger portion of legacy code. also it is challenge to influence rest of team in large organization. Show
Test-Driven Development very good good balance Good balance good Starting exercises were a bit simple but I would say fair starting point. Very knowledgeable and helpful about the concepts of TDD. A very good resource during the training. Bring it on! Definitely ready to follow the principles discussed in the training. Convincing people in other locations / teams working on graphics would be challenge. A challenge that would take time for sure but should be possible. Show
Test-Driven Development excellent good balance Good balance excellent "Good increments of skill and testing; good ramping up of difficulty and forcing concepts; like ""ok; now " I thought you could maybe stress the unsustainability of manual testing more in the start of the course; and impress upon devs that not testing is a false economy. Maybe that might get them on-side faster? Much better Maybe. In the next couple weeks I'm working on integrating someone a driver written by a different team onto our platform; not the best time for TDD since I'm not responsible for the module. However; I will look for chances to use TDD when I next need to bug-fix or fresh develop. Acceptance from other developers; especially those not working at our site. Incrementally applying to our massive legacy code base; especially on modules that are not under our direct control. Show
Test-Driven Development good not enough exercises Good balance good More examples that showcase complex unit testing. Competent about the materials. Moderately Not yet; until the code is properly refactored to run off target. Need to define the right modules in the legacy code to test the water. Having to apply this effectively on legacy code. Show
Test-Driven Development good good balance Good balance good Time allocated to exercises sometime was a bit short to proper digest the contents. Instructor was very responsive and willing to address questions and concerns. He was very helpful during workshop. Much better Yes. I can start applying TDD to modules that in my responsibilities. To convince other people in our team in remote office to use TDD. Show
Test-Driven Development very good good balance Good balance excellent Excellent exercises. Very good approach to conveying ideas and raising questions about why we really may not want TDD. Is it the code is already badly structured -> should think about modularising; etc... Bring it on! Yes. We already do some testing on code we write but we never have it checked in somewhere and not comprehensive. This will help us keep all those tests in one location. stubbing lots of APIs Show
Test-Driven Development excellent good balance Good balance very good Moderately Yes; but planning to do it step by step without affecting current schedule. Legacy code Show
Test-Driven Development excellent good balance Good balance very good Liked the use of post it notes to get everyone to answer questions which led to a more tailored discussion for the audience. Moderately I already started TDD; but now I should be able to do it better. We spend 90% of our development time adding features to legacy code which is going to be hard to add tests to. Show
Test-Driven Development good good balance Good balance very good The exercises were a good way to get introduced to the ideas of unit testing. Helped get familiar with how you should implement unit test in your projects Much better Yes. I will be taking these techniques and getting them started on some of my projects There is lots of legacy code that needs to be TDD integrated. Challenge is to get the TDD unit test frameworks set up and running on this legacy code. Show
Test-Driven Development excellent good balance Good balance very good "Excellent practice; although by the 4th day I didn't want to write anymore ""toy"" code." Very knowledgeable and helpful answering TDD questions applicable to our projects. Bring it on! Yes! I'll be able to start adding a test harness to my project! Separating everything out into to test components individually. Show
Test-Driven Development good good balance Good balance very good A little Yes; but will have to move slowly with large backlog of legacy code. Large legacy codebase Show
Test-Driven Development Good balance N/A Show
Test-Driven Development very good good balance Good balance very good I am not sure if the mock random generator class was excluded from the corresponding Home Automation VS 2010 solution on purpose or not; but I had to manually add its .h and .c/.cpp files to solution. Well knowledged in the subject and easy to talk to Moderately No; it's Saturday tomorrow. LOL. For the next work day though; I will at least spend some time to continue to look into incorporate TDD into my project. Working on the code that's not developed by myself or in-house Show
Test-Driven Development very good good balance Good balance good Calm; competent; patient and seemed to like my jokes and irreverent behavior Much better Sorry Man not writing much code these days but hope to do some practice LEGACY CODE Show
Test-Driven Development very good good balance Good balance very good They were good but getting a preview of the implementation before getting started on the exercise is good and bad. It gave a direction to get started when we had limited knowledge but then it also prevents thoughts on how to do it differently. Good explanations and easy to follow Much better Yes I feel like it will be a challenge to bring the whole production code base into test but slowly it can be tackled The existing code base is not very well structured for TDD. Show
Test-Driven Development excellent good balance Good balance excellent Knowledgeable! Much better Yes. I can start with testing high level code first to become productive with TDD. Dependencies in legacy code. Show
Test-Driven Development very good good balance Good balance very good good; but moving on before completing the exercises felt weird. But perhaps the onus is now on me to complete the exercises. Much better I could given some software projects. I'm going to have to keep up on it using the exercises and other code since I don't have software projects. The existing code on my device is a massive mess; so applying TDD to the legacy code would be quite the challenge. Show
Test-Driven Development excellent good balance Good balance good Awesome : knowledgeable; dynamic helpful and kind. Much better I can. My setup is ready and I managed to find many bugs in few hours Expanding TDD to other modules (using different compilers) But I think it's worth it Show
Test-Driven Development very good good balance Good balance good It might be good to have some more complex code with an emphasis on not finishing it. It would be good to have a better sense of what the real world would be like. Much better Yes! Adapting legacy code Show
Test-Driven Development very good good balance Good balance very good Some instructions were unclear; sometimes not enough time to go through all of them Good Bring it on! No; legacy code is too much of a mess; and I do not have any time to work on that this year (have other responsibilities) Faking out hardware dependencies; making it work with legacy code Show
Test-Driven Development very good good balance Good balance very good I like how the 'simple' excercises lead into interesting tdd related results Friendly! Knowledgeable! Much better Definitely; have all the TDD skills to work on legacy code and new code time constraints; difficulty in refactoring Show
Test-Driven Development very good good balance Good balance very good They were easy to follow yet complex enough to push the comfort zone of tdd. great; approachable and helpful. Much better I can start Monday; tomorrow is the weekend! Timelines are usually determined the year before a project starts; there will be some issues meeting early objectives but will save time in the sustaining phase. Show
Test-Driven Development excellent good balance Good balance very good "My old C experience (10years I do not write in C) has been a issue. I did not understand some ""C"" or C++ details. However I think I got the overall." Thanks you very much James. The quality of your presentations and you course are very good. Much better Yes; however for PLC we need to put in place a solution for running the Test without it be intregrated in the PLC. Apparently there is less chalange that expected. A couple of mechanism in the Siemens PLC programming language could help to apply the TDD Show
Test-Driven Development very good good balance Good balance very good Well prepared. I'm very glad to help me to setup includes and preprocessor on my VS2010; which I did not know how valuable it is. A little Probably no. 95% of my time is not programming (fix hardware; analyze the problem; read documents...) As stated above. When the fix is a line and clearly knows how to test with tool; really required to settled up TDD environment? Show
Test-Driven Development excellent good balance Good balance good The only complaint is most of the time spent is to understand the point of the exercise than actually doing it. James you did a great job. Really appreciated your time and help; and your expertise. Much better Not really. Will talk to the team. Get the feedbacks. Where to start? Does it work for current project? Is it better off to start next project or this one? I think it's still how to start it systematically as a team. Meaning to have a framework; a direction for the entire group. That is to have the buy-in from everyone. Show
Test-Driven Development excellent good balance Good balance very good great Much better Yes. My code is setup in the test environment and ready to be test driven. Creating meaningful test cases. Creating tests for legacy code. Show
Test-Driven Development excellent good balance Good balance excellent Very good. Very knowledgeable and helpful. Much better No. We need a test framework for PLC code testing. No test framework for PLC code. Show
Test-Driven Development very good good balance Good balance very good exercises were actually hard for me and it required alot of thought; I will try it again after the course easy to understand; patience and very helpful; and he knows the subject very well and able to answer the students questions Bring it on! yes because the teacher showed how to implement TDD in my code very easily legacy codes Show
Test-Driven Development very good good balance Good balance very good Helpful and illuminating. You lecture well. Thanks. Much better No: I'm not going in Saturday. Not sarcastically; I can but probably won't integrate it until I have a substantiall bug to fix (I'm in sustaining.). Existing codebase not designed for TDD; relies on proprietary compilers which increases overhead. Show
Test-Driven Development excellent good balance Good balance excellent slightly more time on the input/output hardware exercise. coordinate better planning for pre-course environment set up sessions. the time/dates were not set up with enough notice that I got booked in meetings before the time/dates were announced Bring it on! Yes (just not CAN packets). understanding how the compiler handles make files was a learning curve; but after that smooth sailing thus far writing tests for communication protocols. dealing with legacy production code that doesn't compile outside of its proprietary environment Show
Test-Driven Development excellent good balance Good balance very good Clear instructions -- really showed off the advantages of pair programming Excellent -- I wish he was a permanent employee at Sugar Land Much better I am pretty sure -- my project teams are seasoned and can help me if I have problems 1) The additional time it will take initially 2) Legacy code (if this is required) Show
Test-Driven Development very good good balance Good balance good They are good; but it takes time to understand whats going on in the code. I think the instructor is excellent; I liked the fact that he did a lot of demos. Moderately I can but it will take sometime sometime to become like James Legacy Code would be a challenge Show
Test-Driven Development excellent good balance Good balance very good I like the fact that I had the opportunit to apply what I learned immediately. James is very patient and well versed in TDD. There were not too many questions he could not answer. Much better Yes. I have already begun. I took the class about 4 weeks ago. I have not written many test cases but the book and class notes keep the concepts fresh in my mind. Writting TDD for older code. Currently my protype f/w has no TDD. So rather than try to integrate; I will rewrite by f/w. Show
Test-Driven Development Good balance N/A Show
Test-Driven Development very good good balance Good balance very good Sometimes it wasn't very clear from the explanations on the exercises alone what we were intended to achieve. (Some more info was available in the slides and it would have helped having that info in the code comments as well). This was the case with the CircularBuffer_Print exercise. Otherwise; the exercises were well organized and very helpful to finish understanding the concepts. Ok. Knows the stuff well. The examples that he gives are valuable and the course is dynamic. Much better I feel comfortable to start using TDD on my new code. I'm still hesitating if writing or not unit tests for my legacy code. - Refraining from writing more code than actually needed to pass the tests. - We usually work with plans a tight schedule. I understand that in the long term we will end gaining time; but for the moment the issue is how to accommodate the initial efforts of TDD to the coming deadlines. Show
Test-Driven Development good good balance Good balance fair Beginning exercises are sometimes not well defined. Good presentation Bring it on! I may not start tomorrow to use it due to a strong constraint in term of time on my next development and as I am in sustaining. But it's just a matter of 1 or 2 weeks before using it. Change my way to work and creating tests before coding. Show
Test-Driven Development excellent good balance Good balance very good Great! Great! Bring it on! -Already started on one module. -Some work to get the framework and the new projects into omniworks. "-We need to decouple our code more without increasing codespace. -I work on the signal processing code and need to think about ""fake"" input data. " Show
Test-Driven Development very good good balance Good balance good The exercises were well adapted for learning; good balance between applicability of TDD and what happens in the real life. Perhaps we could see a bit more of repetition; as in: 1/ tell them what you want to tell them 2/ tell them 3/ tell them what you just tell them This could help participants (well; me at least...) remember things better or know where we're headed during the training. Much better Yes can I start but I need to come up with my own test harness; which will take some time. Besides automating the tests with an environment that's easy to use and decreases efficiently TDD overhead; I don't see any major challenge. Show
Test-Driven Development very good good balance Good balance good It is sometimes difficult to start with the exercices as the aim is not always clear. Much better I am not sure we will be able to start tomorrow (under discussion with colleagues) as we are heavily depending on legacy code (so TDD first steps are longer); and only 2 weeks left to deliver some small features... but it is definitely on the scope for the next month. Mainly working on legacy code: not designed for TDD (long functions; improper design) Show
Test-Driven Development excellent good balance Good balance very good well prepared set of files well knowleadged instructor Much better Yes I will apply it tommorrow and I am looking forward to it. after this course I feel well prepared to use TDD on my project Show
Test-Driven Development very good good balance Good balance good The exercises are well-thought in order to understand how to develop using TDD. But these ones could be more embedded software oriented. Clear and helpful during exercises Much better I guess it will be very difficult to implement it on legacy code for timings reasons. But I will defenitely do it on new developments It is clearly to apply it on legacy code. But as I said earlier; I will not implement it on legacy code; but definitely on new developements Show
Test-Driven Development good good balance Good balance fair We focus to much on the system (requirements) comparing to TDD stuff Much better yes but will need still at least a couple of days to be fully ready Educate our manager to deliver stuff later to save time in the future Show
Test-Driven Development very good good balance Good balance good often the specification was hard to figure out. Light scheduler; we were several to understand it the wrong way. Please add use cases. Bring it on! hard: sustaining legacy code not compatible with current legacy code is octopus ^^10 Show
Test-Driven Development good good balance Good balance good Exercises were fine (increasing difficulty). James is very skillfull but it is sometimes hard to follow him in the technical details (especially on new concepts). Much better No because the project is not in the development phase. Being able to create valuable and relevant tests. Show
Test-Driven Development excellent good balance Good balance very good They gave a nice ramp-up into TDD. Bob was great. Engaged the class Bring it on! Already have. Getting others to stick with it. Show
Test-Driven Development very good good balance Good balance very good For a three-day course; the exercises were effective at demonstrating key; useful; concepts of TDD. Bob Koss did a great job! He listened to our questions; and adapted his teaching to them. Bring it on! Yes. I've already started with CppUTest in the newest class I developed. When I have to abstract the hardware in testing code. It seems to me the hardest part of hardware abstraction will be to design effective tests that cover the critical hardware functions while not making mistakes about hardware behavior. Show
Test-Driven Development excellent I can see how using TDD will help me to be more confident with my code in the future. good balance Good balance Two days was a little bit too short for the amount of information that was presented. excellent I liked the way they are set up to walk you through how to set up the tests. Bob did a really good job. I liked how he walked through examples of how TDD can be implemented from start to finish. Bring it on! Yes. I have been going through the book examples. At this point; I can only use it for simple programs. But; I think I will be able to extend it to the complex programs we make as I get more practice. I have to link the code that I write with a lot of code that has already been written. So; my code will have a lot of dependencies. Show
Test-Driven Development excellent Practical examples of how to start with the test and let the production code develop from the test cases. good balance Good balance excellent James did a great job - I think he is a very good teacher & would be happy to take another course from him in the future. Bring it on! Yes - because at the end of the course I was already working on my actual production code. Mocks with expectations. Show
Test-Driven Development very good What TDD was about; how it could improve my way of working and the code produced good balance Good balance Try to convince more experienced engineer to come for the 2 days exercice on legacy code; it could help to have 1st setups and tests working faster! good Some exercice were too quick; I didn't have enough time to go the heart of the exercice and play with the new structures (like mocks) Very knowledgable; it was a great course Much better I will definitely try Always architecture the code in a way that it is testable (difficult on legacy code!) Show
Test-Driven Development excellent TDD allows automate testing possible; and helps design aspects good balance Good balance For beginners; it may help more if more time is spent on the hand-on demo. very good the student versions don't seems always consistent with the answer versions; and this may cause some confusions The instructor is knowledgeable; patient; very helpful. He manages the class very well. Moderately Yes. Major challenges would come from the refactoring work that may be needed. Show
Test-Driven Development very good With experience well thought out and tested software can be created. good balance Good balance Perhaps need a refresher; followup course devoted to more techniques very good Very talented in speaking and knowledge of the subject Much better I will start this coming week. although; I will be using different modules than those used in class. Challenges in organizing again will be challenging. Goo thing is that I will be using the same development environment. Show
Test-Driven Development very good How to break a task down into its most basic testable unit. good balance Good balance make it 2 or even 3 weeks long. good Very knowledgeable Excellent instructor Patient Much better Yes; but only on new development. convincing management to include TDD development time in project scheduling Show
Test-Driven Development very good How to develop tests first to shape production code. Running tests in an automated fashion for every build is very important. good balance Good balance At the beginning; need to walk class through training exercises; keeping everyone together instead of going over it on the projector; then turning everyone loose to complete it. good They were good. The exercises on mocks was a little confusing and more time could be spent on this. Very knowledgeable Moderately Yes; I will. Biggest challenges are getting the production code ported into the test harness environment. Working through the compiler specific issues for the particular target device. Also; developing meaningful and thorough test cases. Show
Test-Driven Development excellent What is TDD and how to apply it using the test harness. How to setup a legacy project to unit test. good balance Good balance I would like to say have some common issues predefined with templates for seting up our own code but setting it up and going through the pain is important for us to do it later ourselves when the project setup is different excellent Challenging and very good in showing the comncepts while having practice. excellent communication; knowledge and helpfulness Much better I can write tests for my existing code to document the testing done and double check the functionality already tested manually A lot of my programmming is on PLC systems and I don't know if tools/ test harnesses exist. Show
Test-Driven Development excellent How to use TDD good balance Good balance excellent Useful techniques that can be referenced later Excellent Bring it on! Yes External dependency Show
Test-Driven Development very good How to use CppUTest harness; and apply it to my own codebase. good balance Good balance Maybe this might not be possible; but perhaps increase the time period for the course. Specifically on the second day; there was too much information for me to digest. very good Choosing partners for pair-programming should not be at random. The participants should be allowed to choose; so that they get a chance to work with the people they are going to work together later in the project. Very good instructions; with a nice balance between lectures and hands-on exercises. Moderately I can start using CppUTest tomorrow at least to a part of my codebase. That's because during the class; we dealt with the tool(s) installation issues and applied TDD to our production environment. Most of the code has already been unit tested; and now we are dealing with challanges of real-time integration and stress testing. Time to market does not allow us to revisit unit testing again and redo it for TDD. We can start applying it to a part of our codebase; though; as a starting point; so that whenever we get time; we can use it to extend TDD test cases. Show
Test-Driven Development excellent - How to think and design for testability - How to make a project migrate to Continuous Integration. - How to encapsulate modules (HAL; OS; APP) to improve testability and flexibility (multiple targets; or platform). good balance Good balance - Spend a bit more time on exercises on mock objects and stubs and maybe a bit less on refactoring. very good - Very interesting and helpful instructor. - The quality of the course is very good: hands-on; and we can easily see how these concepts can be applied in our current/future projects. Much better - I can go on with the changes that I have done these two last days. I am convinced that this approach (TDD)can bring us improvements in quality and portability. Management will have to acknowledge the effort though; and this may be challenging in the short term given the current deadlines. We will probably need help from our SW Metier department; which helped organize the course. - I will need to be able to compile the current target code off the target. I need to create stubs for the DSP BIOS (Texas Instruments OS) Probably a tidious task. Show
Test-Driven Development very good How to make test case. Setup the test environment. Execute the test on my production code. good balance Good balance good GOOD Much better Yes; because by the end of the day have been able to setup the test environment on my production code In addition I was doing part of those test manually. Now I have an automated method Applying TDD requires some skills. Especially design skill; so it requires time to be really efficient Show
Test-Driven Development very good everything is useful. Did not know about TDD before the Pre-Training. good balance Good balance cannot say very good Easy to understand and to apply what we learned! "Good; nice to have ""real life"" examples. Good as he takes some time to help each one of us." Much better Yes. Already started in class! Not breaking stuff; finding a way to separate application code from target specific code in project as it is already developed. My job is about sustaining software already developed (without TDD) and commercialized. Show
Test-Driven Development excellent That it is possible to apply TDD to all the code I have written in SLB so far. But this wasn't completely surprising as I am relatively new to the company (8 months). I feel; that I now have a number of tools that I can apply to my work to make the code testable and can see the benefits already for spotting bugs quickly. good balance Good balance The course was well structured for the week we had. Although it would be nice to have James for longer; we got to a stage where we just had to get on with ourselves. Perhaps having the course somewhere outside of work where we had to stay and bond as a team more would have been beneficial in building the relationships we need to carry TDD forward. very good I found the course exercises where very well thought out; in the way they made you consider the problem and helped to point you to the solution; without doing it for you. The random selected partners for paired programming was a very effective in my opinion; I meant you had to balance your coding style even more; and you don't become complacent. James; was an extremely knowledgeable and approachable character; who made TDD enjoyable to learn. He kept us all on track from beginning to end. Much better Today is tomorrow; and I am tiding up the Tests I did on the legacy code in the workshop for submission into our source management tool Omniworks. I then will look at how much time I have to implement tests for my current code before the deadline. Getting started; I can already see the power of TDD just have to get my current work to a stage where using TDD is time effective. Show
Test-Driven Development excellent Ability to mock hardware good balance Good balance very good Very interesting. Even with limited C experience; I felt very comfortable in taking the exercices. The instructor has been very helpful in explaining the TDD theory; and guiding participants during exercices. Much better We will try to apply TDD especially to new code Learning curve to overcome in order to not see TDD as a time consuming task Show
Test-Driven Development very good testing good balance Good balance C++ perspective poor good very good Moderately yes breaking the legacy code Show
Test-Driven Development very good This process looks like it works! good balance Good balance Possibly a little more on problem solving and looking at improvements to code(refactoring) very good I found they were pitched well. progressively more challenging which was good once confidence had improved knowledeable about his field. good references to other thought provoking material. Much better I could start tomorrow but I need to find a piece of code I can fine tune my learning Legacy Code! Show
Test-Driven Development good The different techniques for breaking dependencies and how these methods will improve the code design. good balance Good balance There was a lot of overlap between the book and the course. 99% don't read the book before the course but for the ones who do they get the information twice. An even fewer number might have actually tried the techniques. The information is good and the repetition as well so I don't know how it can really be improved. Maybe a cheat sheet could be developed listing the different techniques for breaking dependencies/finding seams and references to where to find them together with pros and cons. Or a small example for each. Could be a nicely styled PDF for printing on a poster. very good Nice to have some traps in them that reflects the real world later on. Good to talk about pair programming and show the benefits. The instructor has a lot of experience with embedded and the examples really targets the often overlooked niche of ESW. He is pedagogic and has a good pace making sure that everyone is on the same page. Much better I think I have all the necessary tools to start breaking dependencies in my legacy code and testing code that I from now on touch. Huge functions with multiple dependencies make some of them very hard to test. Even a small change would trigger the boy scout rule and the implications for testing a small change in one of those function would be huge. Show
Test-Driven Development very good The concept of test frameworks good balance Good balance Physical layout of the classroom would benefit from some thought. Dodging the bobbing heads can be something of a distraction very good Comprehensive A fine upstanding example of manhood !! Bring it on! Yes I believe I have learnt enough to start implementing TDD and to develop my knowledge and skill in this technique Familiarity. I am; however; convinced that this will soon become an integral part of the development process I shall pursue. Show
Test-Driven Development excellent How to convert an existing project to TDD. good balance Good balance May be a couple of examples for asm code. excellent They were very relevant to my project. Eg: We use Ring Buffer and Drivers; which were demonstrated in exercises. Very experienced and patient. Would love to learn lot more from him. Much better Yes; I have already started. We have 3-4 people working on it. I think the biggest challenge would be to comeup with a common Mock anf Fake framework to work with for the pieces of code that we are working on. Show
Test-Driven Development very good How to implement TDD in CPPUTEST; ideas of TDD around legacy code and the importance of testing. good balance Good balance Potential for more examples on more advanced topics but overall the exercises (and legacy test) covered most of the important ideas. very good Good level of difficulty; starts low and works up at good pace. Relevant. Friendly; helpful; knowledgable. Good instructor all round. Much better Yes; have knowledge and setup is complete on legacy code test. No; possible deadline near but start soon. Working with (very) legacy code. Dangers of changing legacy code first to be able to test. Show
Test-Driven Development excellent Test Refactoring Design C C++ good balance Good balance very good Useful examples; would have liked to see some in c++ as well. Although I understand this is a C course. Very pleasant and interesting. Much better Will try to. In order to write good code. Initially the legacy code is not written in a testable way; finding the best ways around this may be challenging. Show
Test-Driven Development excellent Some TDD Skills :-) good balance Good balance A little on removing RTOS dependencies; like mocking semaphores; etc. very good Good exercises. Well presented course material and running through the exercises. Bring it on! Yes; I can and I will. I already have some of my code tested (after this course). Convince everybody that we must get started. Show
Test-Driven Development very good How TDD can help us. Refactoring was very useful; along with hints on proper code design structure good balance Good balance Not a fault of the course itself; but the hotel was not ideally equipped for (any) training; which detracted somewhat from the course. good Good - real world enough to be useful (often these things can be too theoretical for my liking) Good - clearly knowledgeable and a nice guy as well. Bring it on! Yes - I have a brand new project which I can apply this to. TDD all the way :-) Applying it to legacy code. The desire of the organisation to try and procedurise the TDD process. Show
Test-Driven Development excellent good balance Good balance very good I liked them. It gave me very good overview of TDD techniques. Excellent Bring it on! I'm using it. Identifying appropriate TDD tools for my need and setting up. Show
Test-Driven Development excellent too many exercises Good balance very good They are good James is great Much better YES; if designing new code. The RTOS (PSOS) header files and MSVS 2010 header files conflict. Still an issue/ Show
Test-Driven Development very good good balance Good balance good Maybe there should be a class for C++ and C# James was entertaining as well as instructional. Moderately I still need to learn more of the OOD features of C# before I can apply these principles to the ncode I am developing. The syntax for C# tests cases are quite different from the exersizes and examples used in the class. Show
Test-Driven Development good good balance Good balance good "It would be better to give us better instruction of each test.For ex; I spend much more time to implement more ""real like"" circular buffer from the beginning; but the intended test is to start from very simple and add in the needed features. I had to delete and rewrite; it was a little frustrating. " None. Much better Yes; I have my VS2010 env setup so that I can start now. However; if my real development team is using eclipse; I will need help to set it up. Management's understanding of the extra time that will incur at the beginning of the project; which will greatly benefit the project quality and schedule later down the road. Show
Test-Driven Development very good good balance Good balance very good They were good; The more they simulate the industry environment; the better. Extremely patient and comitted to teaching the concepts. He diligently tries to ask us about our environment and our specific issues to help us setting the test environment. Moderately Yes and nO. As it was identified in the class; our codes are highly processor dependent and legacy in nature. So we will have to adapt to not touching when it works. Incase of enhancements; I plan to apply TDD by pulling out the function and having test doubles for hardware as it evolves. Explained above. Show
Test-Driven Development very good good balance Good balance very good Simple enough to get started. Apply very well to the kind of problems encountered in everyday job. Very helpful. Makes sure that everyone stays involved. Provides solutions to the students. Moderately I could; mostly because I am starting a project pretty much from scratch. I should have very little legacy code to deal with (I think dealing with the legacy code is a whole different beast) The mindset is very different. It will be difficult to actually write tests and production code differently. Show
Test-Driven Development excellent good balance Good balance very good The random scheduler thing was great; because no one figured out what it was for. Very positive. I liked how you were willing to criticize some students when they were clearly not paying attention. Much better Sort of. Need to figure out what to write before I figure out what to test. Typically I start out by integrating some existing code into new processor; and by the time that is done; I have a better idea about the new stuff. But that is not conducive to TDD. "Coming up with tests. The reality is most code is not fully tested because the degenerate conditions don't happen (we call it properly). Using TDD makes harder to draw the line between ""wasteful testing"" and ""useful testing""." Show
Test-Driven Development very good good balance Good balance very good I did not have enough time on the Mach exercise. Don't think I really understand it yet. Very good instructor. James kept me engaged. Moderately Yes; I have my environment setup and know how to make it work. Slowing down to speed up. Show
Test-Driven Development excellent good balance Good balance very good exercises provide us with a good idea as to how TDD is properly achieved. Great personnality; and has the ability to explain the concepts in ways that we can all understand. Takes time to listen to the students. Provides solutions in a way that everyone can understand no matter where you are in the exercise Much better Yes! I was able to get started in the current implementation of my tool's code while in class 1. Interfacing with hardware specific functions 2. Current dependency of my header files Show
Test-Driven Development very good good balance Good balance very good I thought there was enough exercises just not enough time to complete them during the course. Very knowledgeable. Moderately I am still having problems working with legacy code; but I am going to finish the exerecises before I continue working with my own code. The legacy code that I am working with in not organized in a testable way. It would probably take alot of refactoring and work to figure out all the dependencies. Show
Test-Driven Development excellent good balance Good balance excellent Would appreciate if the instructor would walk through the examples step by step and encourage students to walk through it at the same time step by step. Pause and provide an opportunity for asking questions. This would require more patience on the part of the instructor Excellent! and clearly a domain expert. Extremely willing to help and very helpful!! Much better yes none Show
Test-Driven Development very good good balance Good balance very good all of the exercises were very helpful. I wish we had more time to spend to nail down some of the more difficult concepts through exercises. James explained the reasoning behind TDD very well; and clarified a lot of questions we had before coming to class. Much better Yes; I am ready to practice TDD on my current project in order to apply TDD effectively; refactoring needs to be done to existing code; and I think refactoring will take more effort. Show
Test-Driven Development very good good balance Good balance good Much better I can start applying TDD for the new functionality I will add to my application. I can not do the same for the entire existing legacy code. working with legacy code and having all its functions test via TDD is challenging (it will be a dream come true if this happens!) Show
Test-Driven Development very good good balance Good balance very good good Very good Moderately yes I work in Sustaining and mainly on legacy code which is written very badly Show
Test-Driven Development very good not enough exercises Good balance good wish had more time to finish them very good A little Yes; but; with caution dealing with legacy code that has already worked Show
Test-Driven Development very good good balance Good balance good Moderately Not with the existing code. I probably to do TDD with new added code if it is not too depended on the existing code. The existing is mess. Show
Test-Driven Development good good balance Good balance good Moderately Probably. I have set up the test harness and it is under my production code folder but there are lots of dependencies that I need to resolve. Hardware dependencies and major refactoring. Show
Test-Driven Development very good good balance Good balance very good Much better Yes Acceptance by managers and colleagues that do not understand TDD Show
Test-Driven Development very good too many exercises Good balance good Interesting. Very Nice. Moderately Yes. I got experience. Performance vs. Cost Show
Test-Driven Development excellent not enough exercises Good balance good I think that the exercise for the legacy code was a little bit longer. You helped us very kindly. Much better No. I have to analyze the product specification before coding. But; I will practice TDD in my spare time. Some modules in legacy code are not separated into the HW-independent parts and HW-dpendedent parts clearly. This might make us to apply TDD into the legacy code difficult. Show
Test-Driven Development good good balance Good balance very good Very good exercises to understand TDD better and to gain practical experience. The folder structure in Eclipse is a bit complicated and can be improved to make the navigation easier. James has wide experience in Software domain. He has done a great job to help everyone understand and apply TDD during this training. Moderately I already started Legacy code Show
Test-Driven Development excellent good balance Good balance excellent Practical; really easy to understand and follow even for a beginner like myself. One of the best I have met. Clear explanation; deep understanding of the programming languages. Much better As a newbie in the software area; I need to learn C/C++ first before I can really apply TDD. But I am trying to apply TDD during C study and the TDD approach has already made my study much more interesting than ever before. Writing a good set of test cases would be one of the most difficult things for me. Show
Test-Driven Development very good good balance Good balance very good Since I didn't do any course exercises (as a course organizer); the above rating is merely my overall perception. James's instructions for the course preparation work were accurate. Much better Yes; I can. I used to try to do similar things; although they were surface application software. Mostly; in each project; one man is working under a tight schedule. Show
Test-Driven Development excellent good balance Good balance excellent They are very challenging and exciting exercises. Very good basic C and C++ refreshing exercise Very good instructor and very knowledgeable in embedded development. Bring it on! Yes; I would be using TDD from now on to improve quality of our coding especially in embedded system Applying TDD for huge framework may be very challenging when handling many code dependancy Show
Test-Driven Development excellent good balance Good balance very good Good balance between conceptual and practical Great and kind Much better Already started; I already made my codes portable before the class(though are many #ifdef..); easier to transform to TDD way. So far no Show
Test-Driven Development excellent good balance Good balance excellent Pair programming and working in group is a great idea. Explanation very easy to understand Bring it on! Yes; I will how to mock hardware; RTOS Show
Test-Driven Development very good The number of exercises; their diversity good balance Good balance "Not only one course. A series of course; two in a year would ""force"" to apply. One for entry level and one for advance after taking the entry level training" good The vitality of James was the major factor. The course was well detailed; the pair programming made simpler to apply the techniques. I would say I need James for pair programming in SLB. Really bright thinking. Love that Much better I would say yes. But need to get my environment ready!! The development environment; the framework on which we depend Show
Test-Driven Development excellent Several techniques applicable to deal with legacy codes; to make them testable first before refactoring. good balance Good balance "For SLB; which deals with ""measurements""; examples of ""measuring something"" (interfacing fake A/D converter; saving data into mock Flash memory; etc.) would be very interesting. " excellent I think it was good to focus on C; not C++ this time; when I look at skillset of the other participants. I personally would like to do more exercise in C++ (well; homework I can do alone; for sure). This time; more than a half of participants were non Japanese. I'm afraid some Japanese students had hard time to catch up talks in English; sometimes. Bring it on! Yes; I will. I have a plan to write a small code for architecture prototype; and will try to make it by TDD-ing. Major challenge will be to bring people in a team to reasonablly at same technical level; keep consistent mindset. Doing it alone is easy; but will not pay off as much as done by team. Show
Test-Driven Development very good Techniques for testing code. Testing code not only ensures that it works; but ensures that it's cohesive. good balance Good balance It would be great if we could set up a project that built the final production code with the vendor's compiler. There's way too much risk for a beginner to break the production code. very good Although some of us could not finish the exercises in time; it was great that we could go to the next step with a fresh project. Excellent teaching style. Much better Yes. we now know the tools and techniques for TDD; it's just a matter of refining them. I don't know if anybody was able to build multiple targets (PC test & production code) in one build. This must happen before we can dive in and trust production code tested on the PC. "There is a lot of work to do to catch up with legacy code. Most legacy code is hard to test; it needs to be re factored. Yet we should have tests before re-factoring. ""Chicken or the egg?"" Preparing the tools for TDD and getting more experience with them is going to be a big challenge in the beginning." Show
Test-Driven Development very good TDD philosophy & way of thinking; available tools good balance Good balance good interesting & inspiring Much better yes complex infrastructure to mock Show
Test-Driven Development excellent TDD is useful even for embedded sw good balance Good balance excellent Great. I was impressed. Before starting; I thought we can not apply the TDD to embedded Thank you Moderately from next week. Yes. This is Friday. How to hide RTOS.. Show
Test-Driven Development poor Good balance poor m m More afraid than ever b n Show
Test-Driven Development Good balance N/A Show
Test-Driven Development very good refactor practice good balance Good balance very good Experienced coach Much better I can start now on my automation work integrate test framework to my project Show
Test-Driven Development excellent how to apply mocking; spying; faking techniques to C++. Gained confidence that C and C++ are highly testable. good balance Good balance very good none Good for what I needed which was confidence that TDD is almost as easy in C++ as in Java. Bring it on! In progress. Pushback to the initial learning curve from other developers. I have buyin from the top to set metrics and hold people accountable so it will work out. Show
Test-Driven Development very good TDD process Apply OO principle on C code good balance Good balance The more course hour would be useful since there are more stuff in the course material than I could digest. very good Exercises were pretty good at trying out the concept. James was pretty good at teaching stuff. A little Bring my work environment to the state where I can use the lesson that I learned would be challenging. Setting up the my work environment for TDD. Show