Training Feedback -- 100 entries

Course Rating Better prepared Recommend to Others Most useful Concepts
v
Exercises
Presentation v Discussion Course improvements Exercise rating Exercise improvements Instructor comments Start tomorrow Challenges to applying
TDD for Embedded C Very Good Moderately Yes The biggest takeaway from the course was a preview into the methodology behind test driven development. The examples provided a simple way to get familiar with the mindset and the process to develop well tested code. Good balance Too much discussion I think there was a lot to cover in the 3 day sessions particularly for those who are not able to dedicate sufficient time to reading/digesting all of the optional material available. I feel like the first day was a great introduction and really conveyed the change in mindset that is required for TDD. The second day increased the complexity of what you can do with TDD and helped provide a preview into all of the tools available. The third day seemed to have become more about going from C to C++ which is useful but I don't think there was enough time to cover it well. I was also hoping to learn more about working with legacy and existing code. The course touched on this but very lightly and certainly difficult to cover in depth in a 3 day course. I think overall the course was very informative and exposed the need to dig deeper in certain areas of interest. It also highlighted the need for a more personalized course Very Good I found the exercises to be adequate for the training content. We struggled a little bit at the beginning to find a good way for people to collaborate. I think screen sharing with one person driving ended up working well. The complexity of the exercises was good and the clues in comments of what needed to be done was fairly easy to follow. The only thing I would change would be to make sure there is sufficient time to work on the exercises during the class and not leave it all as homework I think James was a great instructor. I think that if I were developing something from scratch, I could definitely start using TDD. However, the current challenge that we have is how to change the culture of the current team, train them appropriately and formulate a strategy to make the transition to TDD. It is particularly challenging that we deal with a significant level of legacy code We need to properly train the work force. We need to have a strategy to transition to TDD knowing that we have a large legacy code base that has not been developed under this paradigm. Justifying to the company the price to pay to adopt TDD. I feel like TDD makes initial development slower which is also something that the company needs to get used to Show
TDD for C++ Excellent Bring it on! Yes Writing the ABSOLUTE LEAST amount of code to pass the test and NO MORE. This was probably the biggest watershed moment for me. Good balance Good balance Excellent Gave us space to try to do the exercises on our own but was also proactive at keeping an eye open for when we were completely stuck. Good balance. Yes -- I'm in a tech lead role and can plan, require, and mentor other team members to incorporate TDD into the work flow. Also starting a small technology update where we have current code that needs to be updated and have an opportunity to implement tests. Sometimes customers want to get into the weeds of how you do your work. If you need to provide justification, a challenge is explaining the need for "all the extra code". If you can mandate or convince developers to do unit tests, getting them to keeping tests small and narrowly focused; actually getting them to write the test first. Show
TDD for Embedded C Excellent Bring it on! Yes That it is possible to use all this knowledge in C legacy code with less chance of breaking it. Good balance Good balance Concepts like the TDD small steps and mocks can be overwhelming for those who never experienced it. For example, the person I paired had a hard time with this concepts. We paired two times. The first day was hard, the second was much better. 1) in the beginning, propose a really simple pair exercise that would not use any new technique other than the language itself. Just to know each other, get used to pair and the tools. 2) maybe a few words on pairing. many don't know how to do and will be just a "voyeur" 3) you used an expression for describing mocks something like: It will describe what functions your system must call. - this would be good to hear right in first contact with mocks. Excellent 1) at the end of the course, let the student download his dojo exercises (git versioned) so he can compare the steps with your demos and remember how to slice the tasks better. much of the struggle I saw was knowing how much to implement in each step. 2) the circular buffer had an structure that lead to quick understanding: you wrote the first tests letting us making it pass. I think the other exercises might have a couple like this. James can speak directly to your soul. He points out solutions to deep problems you probably didn't even know you had. He only uses jargon when necessary. James expresses himself in simple and polite language. You can feel that he has experienced the pain we feel today when having to maintain untested code and and managed to overcome these challenges. Very nice and friendly person! I had to take three days, and a lot of work was waiting for me -- guess why? bad, LEGACY CODE makes the customers sad. and they will complain! I was able to retake the work and will start tomorrow! To have the discipline of taking time to use it, and above all, to apply the discipline with someone that do not take time to learn. the person might even like what you say, but as soon as you move away, they start to write poor code again. I think will have to write good clean modules to inspire them, and only after this, try to bring them to the TDD side. Show
TDD for Embedded C Very Good Moderately Yes The basic process to following in creating tests: create the test, make it fail first, then write just enough code to make it pass. Good balance Good balance There were several changes to the underlying infrastructure for this course that caused issues on the first day. Test the infrastructure changes better before deploying them. Very Good Good understanding of the concepts he was teaching. Lots of legacy code and our projects are part of larger efforts within the company. This will take some time, but it is worth it. Lots of legacy code and our projects are part of larger efforts within the company. Show
TDD for Embedded C Good Much better Yes Fake it till you make it!! Don't jump in to coding everything that you know you will need eventually at once. Go slow and methodically. Test Doubles. Good balance Too much discussion The course I took was listed as 4 hrs course daily for 4 hrs. All 3 days we went over by at least one hour. Plus we had substantial homework afterwards. I think this course requires at least 5 FULL days. Corporate employees obviously have other responsibilities and if they block only 4 hours then its hard to go over an hour and also do the Homework. Most corporate classes I took, the expectation was that all the work will be done in the class. Because I only blocked 4 hrs I did not get a chance to complete exercises and get deep in to the context. Leaving up the videos and exercises for a couple of weeks is a great idea for those of us who want to catch up Excellent Have enough time to actually complete them. Very good No. As I said I need some more time to catch up to the concepts and get a deeper understanding so that I can apply them in every day work. Getting others on board Show
TDD for Embedded C Good Much better Yes Fake it till you make it!! Don't jump in to coding everything that you know you will need eventually at once. Go slow and methodically. Test Doubles. Good balance Too much discussion The course I took was listed as 4 hrs course daily for 4 hrs. All 3 days we went over by at least one hour. Plus we had substantial homework afterwards. I think this course requires at least 5 FULL days. Corporate employees obviously have other responsibilities and if they block only 4 hours then its hard to go over an hour and also do the Homework. Most corporate classes I took, the expectation was that all the work will be done in the class. Because I only blocked 4 hrs I did not get a chance to complete exercises and get deep in to the context. Leaving up the videos and exercises for a couple of weeks is a great idea for those of us who want to catch up Excellent Have enough time to actually complete them. Very good No. As I said I need some more time to catch up to the concepts and get a deeper understanding so that I can apply them in every day work. Getting others on board Show
TDD for Embedded C Good Much better Yes The most useful concepts for TDD Off target unit testing for new code, new tests was to develop a test (to fail initially), then develop the prod. code to get it to pass, incrementally and together, so that you can build off of each subsequent effort, refactoring as needed as you go. Good balance Good balance I believe in Day 2 videos it helped to show where in the test effort TDD units testing resides. Perhaps show that up front in Day 1, to give folks an initial overview of TDD unit testing, to other testing that happens independently and later on. (integration, more pa/qa product testing) Good Knowledgeable, likeable, and a decent mix of varied experience with trying to keep the current thread or concept being delivered and reinforced via example, and run time training of those live. Perhaps. Trying to decide if cpputest is the right fit for both off target, on target and if so, wether to use Visual Studio, Cygwin (windows), or Linux environments as the test platforms. the above first. need to look and see as well if cpputest on target is something we should entertain or not. possible size constraints, but additionally maybe the bang for the buck switches more to integration tasks on target anyways. Show
TDD for Embedded C Very Good Much better Yes How the tests can help document the firmware design. Good balance Good balance 1. Our site in Lexington, KY (dormakaba Inc.) was never able to use the parking lot. 2. It was difficult at times to hear what the presenter (James G.) was saying. Perhaps a better microphone? 3. When presenting code (sharing "James screen") it wasn't always easy to see the code being presented. Perhaps don't display James while presenting the text? Excellent The exercises are excellent. Very good introduction to TDD. 1. Well thought out delivery of the material. 2. Very good presentation. I would not hesitate to take other courses from this instructor. I'm not sure yet. I 'm happy the course material is available for download. I believe the biggest hurdle will be getting it building. We have already identified the current shipping product firmware code base we want to test TDD in. Management believes it will add time to the development process. Show
TDD for Embedded C Very Good Moderately Yes THe principle to test all the code written. Not only a few paths. And the way to implement tests for testing the written code. Good balance Good balance I would have like more information on how to test the code on target. Very Good Very good speaker, I liked the way he presented the information. Yes on some new code. I need to understand how to implement that in embedded code on traget. Show
TDD for Embedded C++ Very Good Much better Yes Writing tests before implementing all the code. Really makes you think what the code should really do. Good balance Good balance Very Good I think the course duration needs to be a little longer - 5 day? There wasn't enough time to complete the exercises. Show
TDD for Embedded C++ Excellent Much better Yes probably one of the most useful was attempting to keep tests off-target as much as possible Good balance Too much discussion i would say that i very much enjoyed the class and appreciated the hands on exercises. however, i do think that keeping to the scheduled time each day would be more beneficial to those of us who can barely afford the extra time out of working to take the class. instead of going over, i would be okay with less discussion and/or going over people's responses and questions - maybe answer questions in an email later Very Good though it is great that the exercises are simple to help teach the concepts, something a bit more real world might help more - more examples that deal with hardware since this class is specific to embedded engineers - would also appreciate being able to work with the C++ examples in class the whole time James does a great job explaining the concepts and breaking things down in an easy to understand manner. i do still need to have more practice with setting up the test environment and then figuring out how to connect it with my actual code our code is very tightly coupled to the hardware, there is probably more that can be tested w/out hardware than i think there is, but there are still a lot of hardware dependencies - such as controlling a camera or a motor or servo, etc Show
TDD for Embedded C++ Very Good Much better Yes Since I already read about TDD before it was not really new to me, but it was nice to hear the concepts from someone who is "living" this. This is always something different than only reading about the topic. So I would say, the most useful thing here for me was having real live feedback :) Good balance Good balance I understand that this was a basic course for getting familiar with TDD. But I would also like to see more about how we can have support from different tools. Like how does my UnitTest Framework affect the TDD idea etc. Maybe it doesn't, but I think with the many tools out there it could help to have some points for the decision. Good James did an excellent job in my opinion and he knows what he is talking about. Yes! Not so much "new code" but maintenance of legacy code. So it takes some time to refactor the underlying code in my opinion to benefit from the changes for TDD. Show
TDD for Embedded C Very Good Much better Yes Good balance Good balance Very Good Show
TDD for Embedded C Very Good Much better Yes TDD doesn't mean writing *all* the tests first. Write tests in very small steps, run tests at each step even if failure expected to ensure on right track. Good balance Good balance I feel like the large timezone difference was an issue there, creating a disconnect between the theory and time to continue exercices which had to be on next day morning (and not easy to stay focus at during theory late in our time of day). Introduction to exercices could be made even better (see next answer). However may be not much you can actually improve but constraints of participants. Good It was something hard to figure what to do at beginning of exercices, which caused some lost time in you having to re-explain or demonstrate. I feel the difficulty was not mostly related to "how" to do things (i.e. not about applying TDD), but on "what" to do (i.e. what is the goal, first step of exercise). However once on track, I think exercices allowed to try out the TDD approach/tools/framework quite nicely, the cyber-dojo helped well. Keep it up as it is! Much appreciated positiveness, humour and direct approach! We can feel the great skills you have in this domain and you convey them very well. Yes, while we are not too bad on the "how much is tested" side (unit testing in continuous integration, coverage, etc. in place), we learned much on improving our working process to go much more in a TDD approach instead of adding tests after. We also learn much on how to improve the tests themselves and how they are written. It will be a challenge to be able to temporarily "pause" development of new features, improving testing of existing, and then go back to adding features with TDD approach. Will have to convince those waiting on new features (on which we are already late) that this delay is worth it in the long run. Show
TDD for Embedded C Good Moderately Yes Keep tests small, use Descriptive And Meaningful Phrases (DAMP) Good balance Good balance Having less people in the classroom. Checking participants previous experience of TDD and general SW development xp, then grouping them. Maybe having sub-classes? Advanced participant gets quickly bored in a beginner course, and vice versa. It's also the course subscriber's responsibility to check those points. Very Good Having auto-completion; It definitely avoids typos and let you write code twice faster He has a very good experience and many examples and solutions to provide Yes, even today! There's no reason to wait for improvements None Show
TDD for Embedded C Good Much better Yes The TDD cycle Good balance Good balance I should have blocked out the whole 3 days so that I could focus on the exercises. I had work commitments in the mornings (course in the afternoon), so I didn't engage with the exercises enough. So advice to block out the full 3 days could be good. Because we already have unit testing and CI in place, with our version of spys and fakes (via FFF), perhaps a private course would have been better. Still, I appreciate seeing the different ways of doing things. Very Good I enjoyed them and I think they are at the right level. I think getting something to run locally, even if its in our own time after the course, would be valuable. There seems to be a jump between Cyber Dojo and my machine (although we have tests via Unity and FFF, so its OK) I appreciated your experience and knowledge. Thanks! Yes. Lets see how it goes, but that is the intention. I think I have some design pattern issues, and I'm not sure how to solve them. The code works (well) but its in really big FSMs. I need to investigate this more. Maybe it should be in an RTOS of some kind... Show
TDD for Embedded C Very Good Much better Yes The test driven methodology was well taught and demonstrated in exercises. I have learned how TDD is a continuous cycle of testing, making the test fail, and implementing just enough code to make ti pass the code again. TDD is an incremental approach, where at every step we add more to the code while satisfying a list of tests. Good balance Good balance It could be longer ! There are so many things that could still be discussed on this topic Excellent The exercises were impressively well designed. I can and I will ! There are already a few things I can start applying for a new project that I had lying around. None. Show
TDD for Embedded C Excellent Much better Yes I learned the value of taking small steps, "cheating" with the most basic implementation, and in always making it fail first. When I read your book these techniques were something that I wrote off as being the "ideal case" that nobody would ever do in practice, but after using it in the exercises it finally clicked for me just how useful these techniques are. This is not an example of perfectionism, but it is the heart of the whole process. I have a tendency to over-analyze and over-design things from the start, so I usually have a basic draft implementation before I write tests. This has always forced me to climb out of a fairly large hole when I begin to add unit tests, because I have a lot of code to cover after the fact. I thought that skipping the small steps would save me time, but it is clear now that the exact opposite is true. Good balance Good balance I noticed some duplication between concepts you were covering during the session and concepts that you covered in the recommended homework videos. Since we have such a limited time in the class it would be better to not go over the same material twice (probably easier said than done with so much material). I did watch the "extra credit" videos, so maybe this is to be expected. It might also make sense to use some kind of "discussed" tag for the parking lot issues so we don't cover the same concerns more than once. I would definitely use Gather Town in the future. It worked very well even using the basic setup, so I imagine it could be even better with some customization. I wonder if pair programming during the exercises might have helped avoid some of the "I don't know what to do" scenarios. It might also help to have participants do some gather town training as part of the pre-course preparation homework. Excellent Pairing up (using Gather Town) would maybe be helpful so we can bounce ideas off of each other or help each other understand things better. A shortcut key list for the dojo would be helpful. It would be nice to be able to expand the coding dojo window a little bit more. Supporting one split window would help a lot so we can view the code and the test files at the same time. It may be more complexity than it is worth, though, especially to avoid confusion. It would also be helpful to have code completion support in the coding dojo. I noticed that I spent a good chunk of time jumping between files to get function/enum names, and many test cycles were just me fixing typos. A good auto-complete would make it easier to keep focused on learning and experiencing the TDD process instead of switching between files to get the right type/function name. As a Vim user I was sometimes distracted by these minor environment weaknesses, but I know you can't please everyone. James was a great instructor. It is obvious that he knows what he is talking about and that he's done this before, and that he has seen most of the complaints/questions countless times. I was impressed by the breadth and depth of his knowledge on the different testing frameworks and languages. He not only knows his stuff, but more importantly he also knows how to teach it. Yes, I plan on starting to familiarize myself with the CPPUtest framework with the goal of running through your "legacy code" process. That was the most significant challenge when I first tried to apply TDD to my work, and I finally feel equipped to handle the challenge. That helper tool you demoed today was awesome. The process and your tool look to be priceless (as someone who has banged his head against the toolchain while trying (and failing) to tackle this problem before). I think this course has helped fill in most of the little gaps in my knowledge/understanding of TDD, which is exactly what I was hoping would happen when I signed up. It will be most challenging to take the time necessary to get our legacy code in the testing framework. Adopting TDD for greenfield projects or library development will be much easier. It will also be challenging (as always) to convince coworkers of the value in unit testing (let alone TDD). I feel much more equipped to "sell" the process than I was before the course, though. I imagine this will require me to do all of the heavy lifting of getting our code in tests, so that it is easier for others to just add tests without the large initial barrier of setting up the toolchain. I had this problem before when trying to get people to adopt Ceedling (it depends on Ruby, uses a special YAML file for build configuration, and does some magical code generation that can be confusing to set up). One advantage I see in CPPUtest is that it relies only on C or C++ code, which my colleagues stand a better chance of understanding without additional studying. Show
TDD for Embedded C Very Good Much better Yes Do and fix one thing at the time. Not enough exercises Too much discussion Sometimes, the discussions are too long, the discussion can be closed as soon as the answer has been given. 2)The tests names rarely have good names. Is there a coding standard for test naming ? Very Good For the 3rd day, it was difficult for me to understand what is the purpose of each file (even knowing the use of mocks). So, no idea where to write what. A simple header in each file to explain the purpose of each file can be useful. Easy to understand even for french speaking people. James helps the course to be nice and interresting. No, need some more training and exercices to be efficient. But I will use it soon. nothing seems to prevent applying TDD. That's great. Only mock requires to add tools in the setup. Show
TDD for Embedded C++ Excellent Much better Yes in small steps to something bigger with more stability and error handling Good balance Good balance there is already a good level of discussion and exercises Good add more non-hardware relevant examples like UI - QT development not all of the listeners have liquid coding skills maybe it helps to ask more individuals no I can't start direct I only learned the theoretical part and now I have to consolidate it with the practical The TDD has laid a solid foundation for this Nobody is well versed in a subject after 3 days to convert what you have learned in the embedded system to UI concepts in an efficient way Show
TDD for C++ Very Good Much better Yes TDD concept conceive a program from a testing perspective refactor legacy code Good balance Good balance Very Good If the questions are asked in an optimized way, it can quickly help us to understand them Very interesting, logical and very conscientious in answering participants' questions a little bit hard, I need to learn more about the qt unit testing environment A slight clash with the current design concept in qt Show
TDD for Embedded C++ Good Moderately Yes Clear structured process for development. Good balance Good balance more examples Good - Good - - Show
TDD for Embedded C++ Very Good Much better Yes How to resolve dependencies. If you just need to test a small part of the code. Good balance Good balance Very Good Nice to have would be able to open multiple tabs in cyber-dojo. It would make it easier to have CPP and header files by side to side. (I think it's more cyber-dojo feature request) I would definitively try. The code has many dependencies. Show
TDD for C++ Excellent Much better Yes Do things step by step, but small steps. Smaller than expected. How concretely write tests before implementation. I have the theory but I never known how really apply this. Good balance Good balance Sometimes it could be fast. The day 2/3 was the hardest to follow. Good The exercises of the days 2/3 should be more step by step with demo after 2/3 step to see if everyone has well understood. Like we did it on day 3. ON days 1 and 3 the exercises was very good. Impressive knowledge. The presentation was very good and the online tool to write code was very interesting. On my personal works or works where I can decide, yes, and I will. On Rational project I not sure. It not depends only on my wishes. Also our code is very legacy. Get new habits Splits everything learns the software design patterns compatible with tests Show
TDD for Embedded C++ Good Bring it on! Yes Must useful thing I lerned is for following rules of TDD, I need to write code in simpliest way. Then proceed by small steps to write test and improve/grow code. Good balance Good balance Maybe course and example can be mixed. For example, the first exercise can be inserted inside. It obviously means that time to doing exercise should be reduced but at least, poeple can interact more with instructor and they are not blocked too long. Very Good It could be an improvement to have more clues for finishing tests after the training. So we can have a full corrected example. He is patient, very understandable. I can start tomorrow with a simple class. What could be a problem is to test a big existing class, because writting simple test can be difficult to think. The refactoring to allow mock and fake classes could be a real challenge. Show
TDD for Embedded C++ Excellent Much better Yes Keeping things working while doing changes. Making one small change at a time. Good balance Good balance The website (wingman-sw.com) could be more structured, I sometimes didn't know the correct order in which I should process information. Excellent I had a tiny c++ editor field on a huge widescreen display. James provided calm guidance especially in the leagacy code workshop. I was always under the impression that he knew what was going on and was not worried about any problems. I already did Each new legacy module has to be put into a test harness first before starting. Show
TDD for C++ Very Good Much better Yes Making small steps does help! How to get legacy code into a test harness in a structured way. Good balance Good balance -- Very Good The exercises are very good and the online platform is super useful. Very broad range of experience, comfortable presentation style and speed (for a non-native speaking audience), good answers to the asked questions Yes, I already started test driving a new class. For testing the legacy code, the tremendous amount of dependent classes. Show
TDD for Embedded C++ Excellent Much better Yes I heard about TDD before the workshop. But I could not imagine how to apply my knowledge in my daily work. Your exercises (both training and legacy code) helped a lot. Good balance Good balance The attendees must be aware that there is a lot of homework to do. 1 hour per day is not sufficient. The free day between 2nd and 3rd training day helped me to do my preparation. Excellent Your support during the exercises was very helpful, thank you. But it is hard to focus on the exercises when there is a discussion in the main room. Please use the breakout rooms for discussions. Mary Sue joined our training as German Co-Trainer. It must be very boring for her ;-) There were only a few vocabularies that needed to be translated for some attendees. I think it would have been sufficient if we had translated the most important phrases to our colleagues. First we have to decide in our organization how to use our knowledge. And there is still so much legacy code... It is not the question if we want to use TDD in our organization or not. We have to define a common understanding how to use it. Show
TDD for Embedded C++ Very Good Much better Yes - Separating of test classes and methods - incremental approach Good balance Good balance provide some cheat sheets or summeries to download and to remember Very Good There could be some additional class diagrams or illustration. The dojo web solution works really good. would be possible the new feature vs. quality balance must kept in mind Show
TDD for Embedded C++ Very Good Bring it on! Yes There is no shortcut to success. Development without testing is faster, but it just a matter where you spend the time. With TDD in testing, without in painful debugging. And the tests will aid you in further changes as well. Good balance Good balance It's a matter of time. I think you did the best you could within these 3 days of training. Very Good I think most problems I had were not based on the quality of the exercises, but on my ability to adept the tdd way of thinking. I liked that he addressed the problems of each individual person so that they did not get left behind. Should be, yes. I think I am capable of doing tdd right now, and the additional workshop helped alot. But I think we all have to find away do adapt the concept to our everyday work. I think it's the same for everyone: time vs. ideal execution / implementation Show
TDD for Embedded C++ Very Good Much better Yes The feeling for TDD (the exercises are really, really good!) Good balance Good balance Taking notes on the slides is a bit difficult since you are in front of the line number using zoom. Therefore, it is not so easy to find the right slide (since you adapt the order of presenting the slides to the questions in the parking lot). Maybe it is possible to move the slide number e.g. in the bottom left corner? That would be great. Excellent Since I don't program close to the hardware, it was difficult for me to do the bit logic in the flash driver exercise. Maybe one short introductory slide or some notes in the hint section would be helpful. Easy to understand and always very friendly. James was the first one who introduced mocks in a way which I can understand. Thanks a lot James! I think it is still challenging to transfer the learned stuff to our real project, but now I have an idea where to start. The legacy code training was really cool. Too many dependencies and code which is not test-friendly. It would be easier to start with a simpler example. Show
TDD for Embedded C++ Excellent Much better Yes how to use fakes for testing and that it could be useful to modify the design for a good testing and fast development. Good balance Good balance The script could be a bit more structured (not just bare slindes but a summerized article about the contents). It is not very intuitive to find your way around the homepage (I had to use bookmarks). Excellent Sometimes it was not easy to listen when there was a discussion going on in parallel because I was so focused on the exercise. It could be easier to have discussion breaks every 30 min with good and bad examples. It was really fun to do the exercises. the examples are well chosen and the instructions as comments in the code easy to understand. I will try. I do not have very much programming experience, so it will take me a while to completely understand the ideas. We have a lot of existing dependencies and very much "hard-to-read"-code where it is not trivial to define testcases. Show
TDD for Embedded C++ Good More afraid than ever Yes to think in another way; it's strange, but (hopefully) useful Too many exercises Good balance Good I'll need more time to recapitulate the new concept; hope, the WS will help Show
TDD for Embedded C++ Good Moderately Yes The TDD workflow. Not enough exercises Too much presentation Good Maybe instead of 3 different exercies, 2 or one that are extended from day to day. This would reduce the hurdle to get into new code every day. Also the solution code of day 1 can be used as day 2's starting point, so a trainee would see the intended solution een if he didn't have the time to watch videos. A lot of dependencies that will take a lot of time to mock (etc.) for testing. Show
TDD for Embedded C++ Very Good Much better Yes Apart from the concept of TDD, the topic was completely new to me. Now I have a good overview of why and how. In addition, lots of practical information on how to start using TDD methods in daily work Good balance Good balance Very Good James is a very knowledgeable trainer with huge experience. Well-prepared daily routine with preparation, course with new topics, follow-up work I don't think so, but it doesn't depend on TDD courses. It is a larger project and first a uniform infrastructure, rules, tooling and directory structure must be defined. Show
TDD for Embedded C++ Excellent Bring it on! Yes How extreme TDD can be done, esp. the step by step way of thinking is amazing to me. Good balance Good balance The language border (German) was not so easy to handle. You did all your best with translator. Excellent Yes, I can. I started downloading and doing the exercises beside the training on my local machine. The management and legacy code. The management needs fast results. The legacy is a hard burden. Show
TDD for Embedded C++ Excellent Bring it on! Yes The importance of writing testable code. Good balance Good balance 1. Request more participation from the audience by asking more questions. 2. Explain test doubles in more details. I still don't know the difference between a stub and a fake. 3. Explain exploding fakes technique in more details (and what it achieves). Add explanation video or link as homework before the workshop. Excellent 1. It was very hard to focus on the exercise implementation with a parallel discussion. Maybe ask attendees to post a message on the chat when they need help, and break out the room to a separate call to speak to the ateendee alone? 2. Post comments/observations about the exercise resolution directly to the developer on the attendee webpage. And maybe only highlight the most meaningful to the team before the course starts. 2. Publish complete exercise solutions on the website (source code on top of video) 3. Make exercise instructions clearer. Embed them or add a link in the cyber dojo space. Or post full textual instructions in test class source code as comments. I recall not knowing what to test in the mock example. 4. Sort the exercise files by alphabet on Cyber Dojo. If a source code file should not be modified by the attendee, then set a lock (or a comment)? Very good! I'm on it :) Management puts a LOT of pressure on feature development. It was embedded into our developers, they struggle switching to this new TDD mode... Show
TDD for Embedded C++ Excellent Bring it on! Yes I want to say that I learned a brand new and efficient way to developp, and that my "naive way" of thinking developpement was not so bad... Good balance Good balance Very Good I think I would be able to start tomorrow (at least on a new project). Breaking the dependencies maybe Show
TDD for Embedded C++ Excellent Bring it on! Yes I want to say that I learned a brand new and efficient way to developp, and that my "naive way" of thinking developpement was not so bad... Good balance Good balance Very Good I think I would be able to start tomorrow (at least on a new project). Breaking the dependencies maybe Show
TDD for Embedded C++ Very Good Moderately Yes Complete new strategy of how to develop code and a new point of view. Good balance Good balance Sometimes the presentation or demo with the source code of the exercises was a bit too confusing or hard to follow because of too much jumping around in the source code. But maybe it was just because the timing of the course was not so good planned which is not the fault of the course but of the time scheduling itself. The fact that we had meetings in the morning and normal work already half a day and then there a lack of concentration in the evening. Very Good I cannot start tomorrow since my main work is no longer so much C++. Show
TDD for Embedded C++ Excellent Much better Yes Good balance Good balance Good I was a bit confused in the beginning on how to get started. At first I did not understand the "simulated discussion" in the comments and the marker for the tests. Maybe instead of simulating a collaboration it could just be in the form of "do this task, now do that task". Show
TDD for Embedded C++ Very Good Much better Yes For my part, I really learned to have a strategy in order to set up unit tests, a real approach, also to be able to understand well how to interact with a refactoring of a code. thank you very much James Good balance Good balance For someone who is not native to the language, sometimes it was just a little too fast. The other details were more about our company, not having time to prepare and do homework. Very Good the exercises were interesting, I just lack of practice, suddenly I had a little trouble The instuctor was perfect and interesting. I will be able to start trying to apply it hoping I can really make it sucessfull I think the difficulty is the size of our code (5 years of development) and a big lack of testing. It won't be easy Show
TDD for Embedded C++ Excellent Bring it on! Yes What TDD is really about and why going slow is faster. Good balance Good balance Make sure attendees know to keep the training days completely free well beforehand. Maybe if because of timezone differences the attendees have the time before the trainings, give some more preparational material beforehand. Excellent For some parts of the code, we can start yesterday. For others, we still need to restructure the folders and cmake scripts (which is already planned), get to an agreement on where to place shared fakes and discuss some architectural issues that introduce a lot of singletons that would otherwise introduce bad hacks into the code if we tried to test them. Lack of testing knowledge - I think your training will get us going. Show
TDD for Embedded C++ Fair More afraid than ever Only if improved How test stubs and mocks work. Too many exercises Too much discussion I didn't had enough time to do all homework exercises, which meant that I couldn't quite follow the material the next day. It seems necessary to me to extend the duration of the training to 5 days so that the homework can be dealt with directly in the training. Fair It is good to be able to ask questions at any time if someone have a problem in the task, but a discussion in the chat should be avoided, as it is very difficult for the others to concentrate on the task then. No, because through this training I have the feeling even more that I lack the necessary knowledge to set up suitable tests. Many dependencies Long code Show
TDD for Embedded C++ Good Moderately Yes Since I had only experience with gtest I have learned to work with cpputest. Good balance Good balance I'm sorry, I have no idea. Very Good The exercises have already a very good state. I have enjoyed your presentation very much, thank you. I think yes. I've used TDD already in the past. Show
TDD for C++ Very Good Moderately Yes changing how my brain approches a problem dividing a problem into small steps (it's a huge change !) coding tests can be interesting and fun and does not take that much time (in an environment that enables tests to be done) Good balance Good balance it's a bit difficult to attend the full course AND practice homeworks while keeping half a day of workload. Maybe tell companies that they need to free attendees for the whole day, so they can focus on subjects Very Good maybe with a concrete case where 3 classes have to be tested independantly, but also together ? One difficulty is to work on the exercise while the instructor talks with other attendees. It could be interesting to have a special zoom room acting as an "instructor desk" where people could queue and get their help/answer from instructor each after another. That way, people don't get distracted. And if the instructor wants to say something for everyone he can just go back to the main room and tell his thing. James was a great instructor, I personally understood him well, and he was able to rollback to unanswered questions or misunderstandings. I appreciated the exercises provided (though it was a bit too low level/hardware related) Hopefully we can use it in our refactoring process. I would say I can start based on some example you have provided. main challenge is the time given by our managers for that. They need to understand the whole test subject has been put aside for many years, and if we now want to make things reusable, we have to spend time on it now and can't reach our objectives without them. Technically, I think this can be applied on our product and it will me even more useful to people dedicated to providing new features. Show
TDD for Embedded C++ Very Good Much better Yes Good balance Too much presentation Fair Show
TDD for Embedded C Good Moderately Yes Good balance Good balance Good Show
TDD for Embedded C Excellent Bring it on! Yes I really enjoyed every moment of James TDD remote learning and think it can help developers at any skill level. There were so many great lessons packed into the workshop, plus a variety of bonus and video material that is a must watch afterward. You can see how much time and passion James puts into the topic of TDD and is so eager to help his customers understand it. Good balance Good balance More attendies :) Excellent More exercises :) The hands-on programming exercises immediately promoted deeper understanding and learning. The direct and immediate feedback in the exercises was an invaluable help. I am already in the process of adopting TDD immediately after completing the course. I spent a day setting up my development environment so that I can compile and run tests with the click of a button, just like we did in Dojo. James' book has unfortunately moved to the back of my shelf in the last few years, but now it's back on my desk and will accompany me in my daily work in the near future. Inspire colleagues to write unit tests as well to have more weight in convincing management. Show
TDD for Embedded C Excellent Bring it on! Yes I learned through experience the discipline required to write tests first and avoid introducing untested changes, but also the code quality and confidence that TDD brings. Good balance Good balance Excellent Perhaps add a few more stopping points during the exercises to quickly demo what "good" looks like so no one gets stuck in implementation details. James makes a compelling case for TDD and ably guides attendees through discovery. I'm ready to start TDD *today* because I'm convinced it works and have the resources to get started. Complex legacy code that makes introducing tests difficult. Show
TDD for Embedded C Excellent Much better Yes Becoming aware of Refactoring in a useful sense. TDD can help me in a huge way. It also gave me a good mindset for appraoching legacy and safety challeneges. Good balance Good balance Maybe add an overview of flow for TDD. A context diagram of the process and toolsets available. A virgin approach overview and then a legacy approach overview. Very Good Exercises: Maybe simplify a few of the requirements. Some were a bit vague, needed a bit more detail. Excellent presentations and extremely knowedgeable. Yes. As soon as we start the next sprint we will begin working on TDD with refactoring. Time and resource availability, but we do have room to work this in. Show
TDD for Embedded C Excellent Much better Yes Take very small steps. Good balance Good balance I lose focus easily, so maybe during some of the longer demos or talks asking more questions. Excellent Knowledgeable, practical, fun, hilarious - definitely would have been much laughing together if we were in person! With some of the general concepts at least, but in the near future yes. Legacy code, but this was discussed which was helpful. Show
TDD for Embedded C Excellent Bring it on! Yes expressive style of testing.... oh and the cyber dojo tool was pretty nifty Good balance Good balance More interaction from attendees perhaps. Everyone turned off their video and at some points it might as well have been a youtube video. The advantage of live training was lost during lecture. Excellent Yes None Show
TDD for C Excellent Much better Yes The fact that I can develop basedon the test cases ahead of time Good balance Good balance Excellent Show
TDD for Embedded C Excellent Much better Yes I learned how to better think about breaking problems down into small, easily testable, steps. The demonstration on Day 2 was very valuable to me in learning how to fake/spy different portions of the system. These are practices I have little experience with. Good balance Good balance Excellent Perhaps more nudges. I became stuck a few times in the in-class exercises trying to understand 'next-steps' in the program, which led me to occasionally implement more steps than I should have, or not really understanding what needed to happen next. Very helpful, and very attentive to the needs of the class. Absolutely! Just need some more practice in application. Currently none. My employers are 110% behind TTD. Show
TDD for Embedded C Very Good Bring it on! Yes Test first! Good balance Good balance Strict breaks with remote "coffee talk" Good Introduce fixed checkpoints that all are on the same level certain time. Top! Already started yesterday with the integration of the CppUTest harness into STM32IDE To take other colleagues with me. Show
TDD for Embedded C Excellent Bring it on! Yes Enjoyed the discussion of Zombies. Good balance Good balance A little polish could be added to hosting. There was an undue number of points where the wrong screen was shared, weird keyboard errors and the like. This distracted a little, but was not a big deal. It strikes me that there is another course to be had in teaching approaches for design for test, especially in the RTOS context. Hitting on "Active Object" and "Functional Core, Imperative Shell" as tools for isolating state and improving testability, for example. (I think this would have been helpful to the one person who kept asking about testing in a concurrent environment. It gives a practical explanation of how to NOT test with concurrency for the bulk of development.) Very Good I only stalled on the start of the mocking section, and that was my own fault (got a call during the explanation.) The instructor does a very good job, missing practical and ideal approaches. Yes. I'm hopeful that this maps to the others in my team, where this really matters. Yes for me is because I've been using TDD for a while. For my team, I think the hands on approach opened their eyes and helped map this to real world practice. Social. Those on the team who are resistant to change. Show
TDD for Embedded C Very Good Moderately Yes Coming in to the course, I have already practiced a little bit of TDD. Although most of the tests I have done is mid-level, hardware-in-the-loop tests. I needed more training on unit tests, especially in embedded systems. I really liked learning about mocks and actually having a chance to work hands on with a working framework. It is quite different hearing about it from videos, and actually doing it. Not enough exercises Too much presentation I think extending the course from 3 half days to 5 days would be better to have more time for exercises. Very Good I'm not sure how capable the editor is. It would be nice to go over a few of the more common shortcuts that the editor has, such as commenting out a block of code, or search and replace text. Someone else figured out how to do a revert, which I haven't. Also it took me awhile to figure out how to get back to the test output after navigating to the source code. For awhile, I kept re-running the test so I can see the test output again. I liked how James was able to give feedback to the students during the exercises. I was amazed at how he was able to recall and show the actual steps wherein some students struggled a bit to the group. James does tend to keep talking without pause. I found it hard at times to ask questions during the lecture. Some of that is on me though, as I'm a bit shy and hesitant to disrupt. Maybe. Our team is transitioning from C to RUST. We are still learning about the new language, and the tools associated with it. Having to learn a lot of new things at the same time. Show
TDD for Embedded C Very Good Bring it on! Yes hands on TDD with sample problems Good balance Good balance As a C programmer, everything related to C++ was unfamiliar to me. Some of the videos that were recorded during previous in-person classes were hard to see/hear what was going on. Could not hear questions, could not see white board. Excellent The exercises were great - easy to get started, but then lots of room to keep working and expand on concepts. Very helpful, friendly, knowledgeable yes, I am planning to start using TDD immediately in my development work. large legacy codebase, software not well-partitioned into independent modules Show
TDD for Embedded C++ Excellent Bring it on! Yes The most useful things I learned were how a Mock works and how to apply TDD to legacy systems. I was exposed to Mock via a Clean Coders video, but I didn't understand the difference between Fake, Spy, and Mock. After your presentation and exercise on Mock, now I do. Applying TDD to legacy systems didn't make sense until you showed us your automated way to do it. Getting the test to compile and link with the legacy code is the biggest stumbling block and you shared a clear way to do it. Even if I have to do it manually, I now know an straightforward way to add TDD to legacy code. Good balance Good balance The only improvement I can see is to incorporate an extra short break or two. Granted we were working remotely and could walk away when we wanted, but I didn't want to miss the information being presented. I usually waited until we started the exercises for my bathroom breaks. This put me a little behind the others, but I was able to successfully finish the exercises after the class ended. Excellent The exercises were very helpful. They provided opportunities for us to stumble and make mistakes. But at the same time the exercises kept us fenced in by the files we were not changing, preventing us from getting too far off course. My only suggestion is to add a few hints for the Mock exercise. I had difficultly understanding the first step, possibly because I was confused between starting Part 1 and Part 2. Once I got the first two tests working, the concept clicked and it was smooth sailing for me. The instructor is top rate!! This was the most useful software class that I have ever attended. I can immediately apply the things I learned. The quality of the exercises show that a lot of thought was put into creating the course. The circular buffer, the light controller, and the Mock example provided the right level of complexity to teach us the concepts and to identify the pitfalls when we hit them. During the presentation, I liked that the instructor walked through examples, intentionally making mistakes that we might make, giving us insight into the thought process and teaching us how we would correct the same mistakes. If I was working by myself, I would start tomorrow! Unfortunately, our engineering management wants to develop code with our team. We are told that we are using an "agile" approach to accommodate changes, but we are really just not taking the time to understand what we are building. So far, in three months, we have changed processors, changed languages (to Rust), changed the number of processors in the system, and been told that we don't need to know the requirements to get started coding. In the last three months, we have accomplished virtually nothing on our project. This project is a disaster and the demoralized software team is no longer making suggestions on improving the situation. This is not the fault of TDD or the course, this is a management issue. Perhaps I can use my TDD knowledge when my manager quits or at my next job when I quit. We are forced to work as a Mob on a single, shared computer. Unfortunately, our manager codes with us and our director wants the boss to take a leadership role. The intent of the Mob was to share our skill sets, but that has not happened because of the large experience and skill disparity between individuals. This has caused frustration in dealing with people who are unable or unwilling to get out of their comfort zone and learn something new. Also, when your boss is in the Mob and trying to take leadership, it's impossible to get one's ideas weighted equally. We tried explaining dependency injection to the boss, but he didn't understand C++ and did not consider dependency injection to be important. We gave up trying to improve things in the Mob environment. Show
TDD for Embedded C Excellent Much better Yes Good balance Good balance Excellent I think moving into things like mocking of hardware and things like databases would be good and help to make it closer to what will be experinced in the office. Or finding an old open source cod and use that as a legacy project that has to have tests added to it. Yes. I already converted my tool chain to CppUTest instead of gtest, and moving forward in TDD Legacy code Show
TDD for Embedded C Very Good Bring it on! Yes Really liked see another style of TDD Not enough exercises Too much presentation Excellent Group was pretty quiet, I think continue to experiment with driving higher engagement! I don't think this is a problem with you as the presenter. In person (post covid) will likely naturally solve a lot of that! Yes. I often learn a new programming language by first creating a simple test. I typically won't use a language that I can't get tests working fast A split between some developers using TDD and others not. Getting others into the habits of thinking test-first. Show
TDD for Embedded C Excellent Bring it on! Yes TDD Good balance Good balance Excellent funny, and easy to understand. now Show
TDD for Embedded C Excellent Much better Yes Learning about test harness Good balance Good balance Adding examples of interrupt processing and handling. Excellent Show
TDD for Embedded C++ Very Good Moderately Yes That there exist readily available test harnesses for testing code changes is definitely an eye opener Good balance Too much presentation Very Good Definitely can't start tomorrow as my primary work environment is restricted in the kinds of software that can be installed on it so the test harness would be difficult to integrate Show
TDD for Embedded C++ Very Good Moderately Yes Good balance Too much discussion Excellent Show
TDD for Embedded C Excellent Bring it on! Yes I found it very useful learning about how TDD can be used to reduce debug time because it reduces the number of bugs that are coded into the system in the first place. In addition, I found it very useful to be walked through the TDD process step by step and understand the methodology, and now I will be trying to implement it in my own work. Good balance Good balance n/a Excellent I don't think there are many ways that the exercises could be improved, I enjoyed the exercises a lot. However, I think maybe adding in some kind of pair programming if it is possible might help some people. So one of the students would write the first test in an exercise and then the other would write the second test etc... something like that. I thought James was a great instructor and made the material easy to understand! The exercises went well with the course material. Yes. I was working on a Deep Learning framework in C and I have started to incorporate TDD for some of the basic mathematics libraries I am writing. n/a Show
TDD for Embedded C Excellent Much better Yes Unit Testing is more important than I ever imagined... Not enough exercises Good balance There are unfortunately only a few hours for the course so I understand the time for exercises are limited. However, I would have loved to see more opportunities for guidance in analyzing various problem statements (similar to buffer, scheduler and flash driver). They do not have to be exercises to the extent that we did the others, rather just walking through the process of 1) determining the required components/interfaces, 2) determining the required tests. Excellent I don't believe the exercises requires any improvement per sé. However, there is no opportunity for deriving the interfaces and various tests. Instructor was very knowledgeable, friendly and willing to assist. Yes, although setting up the environment in windows for GCC proves to be tricky... Mostly time, although I understand that the long-term time benefits outweigh the time spent on the initial learning curve. Show
TDD for Embedded C Excellent Much better Yes That TDD pays big dividends; there is an upfront cost, but it's worth it. Good balance Good balance Really enjoyed the course, the first day was a bit of a culture shock, but that's because it's vastly different from how I have coded in the past. Excellent Not sure. Great instructor. Yep starting today. Time pressures, usual and a culture in the office that doesn't like testing stuff. Show
TDD for C Very Good Much better Yes 1. There will be bugs while writing code but it can be fixed easily then and there with the TDD. 2. The production code should be modular and written in small functions so that it can be tested fully. 3. Untested code should be removed as quickly as possible. 4. Comments should be put to describe "why" rather than "how". 5. Development can be started and tested without h/w. Good balance Good balance May be before starting the exercise, the functions/files being used are explained a bit better. Sometimes user does not know how to start. Demo videos are there for some but then the whole exercise would be irrelevant if we watch it beforehand. Very Good A little bit explanation about the common errors we face. May be similar to Instruction sheet, some common error sheet should be there. James is a very intelligent man and knows what he is saying. His explanations are good and relevant. He knows how to keep a boring session interesting especially that Legacy Code stuff. I have started already. I want to put forward my knowledge ASAP. But it will take sometime to actually start i.e. getting an output. 1. No Challenge as far as management is concerned, as I am encouraged to put TDD into my daily routine 2. The actual challenge is to put the frame work and then start it Show
TDD for Embedded C Excellent Bring it on! Yes I just proved that I learned this tonight. To slow d..o...w.....n and complete one thing/step at a time. I was installing a testing framework for SwiftUI ViewInspector... and it was failing and reporting errors that was just WRONG. So I took a page from James' book and started back at step 1. validate that it was complete and functioning... continuing on for several steps - I found my skipped step and when it was corrected - ALL WAS HAPPY IN THE WORLD! Good balance Good balance Maybe... add a half day - option - to consult and put the students code under test at their work place. Excellent I loved how the first exercise - had already written the test... we just needed to implement the code. Then read the feedback and discussion in the test file - and relocate the pointer ... that worked very well. Maybe have a short video 1- 2 min,. of James discussing key points of the test/implementation every now and again... What a great guy - very humble and giving of his experience and knowledge. Sure - started today... tomorrow will be easier,. none. Show
TDD for Embedded C++ Excellent Much better Yes TDD and small increments (I did non know the techniques before). Good balance Good balance One day more was advisable. Excellent I think they are very well done. Careful that in the last day exercise the comment about being ahead was not applicable in what I was doing. I just made errors and I got the message. Good balance of amusing remark and serious learning. Very competent. Surely not with the main legacy code. I'll try with a small library, first, to get more exercise. Than I'll try the application to my monster code. For sure I'll try to apply it to any new code I'll start. 1) Me and my team collegues, work in a cmake environment (me using also eclipse as text editor and debugger) and, not being a software engineer, I will have to solve the problem of how to use/adapt your tools (anyway I was able to compile and debug the CircularBuffer example using eclipse just modifying your cpputest-starter-project). 2) I still do not see how to work on my legacy because of how complex the code is. On the other hand, trying to add test to the software could improve the code organization (as a plus of all the other TDD good thing). Show
TDD for C++ Good Much better Yes Write test first before writing any production code. Small changes at a time, keep test passing all the time, at max one test can fail during development. Refactor coded based on tests developed along the way. Good balance Good balance . Good . . Yes, I have been trying to follow TDD but now concepts are more clear now. . Show
TDD for C++ Very Good Moderately Yes As a complete beginner to TDD, I gained hands on experience in writing code with TDD. I found learning how to refactor code while keeping tests intact very useful. Good balance Good balance Starting each training day with a short overview of what is going to be accomplished on that day. Very Good - The instructor did a good job of engaging the attendees in discussion, and explaining the concepts in an easily understandable way. Maybe not directly into my work yet, as I feel like I still have some learning to do. But I do feel more confident to try this out for myself. To a TDD beginner, it might take longer to get the actual job done on time (deadlines). Show
TDD for C++ Very Good Moderately Yes Good balance Good balance Very Good Show
TDD for C++ Excellent Bring it on! Yes focus and solve one problem at a time. Optimal solution evolves iteratively and incrementally ZOMbie approach, walking skeleton, just enough thinking to get started balance of slides and demos/hands-on assignments to experience pure TDD approach systematic approach to exploratory work, fast feedback and learning cycles to adapt every build/test failure has clue in it to do the next logical thing...just decode and code Keep the system working! do not break it... Good balance Good balance Can't think of...There is a lot of content to process/digest and internalize...but it is worth it. Excellent perhaps the students should prepare more, ask questions and work on demos side-by-side at the pace of instructor :) and sincerely complete the assignments to really learn/understand TDD Awesome! PPTs and recorded videos must watch. James addressed all the questions even those which were very basic ones. Demos were good. Thanks a lot James, looking forward to apply these new tools in our toolbox. Sure. The earliest we can start is "right now" will definitely apply these techniques learned for the codebase at workplace. simultaneously invest time on problem solving TDD way! That would help develop TDD mindset, iteratively and incrementally...plus its seems to be fun and different perspective Show
TDD for C++ Very Good Bring it on! Yes Incremental coding with tests to validate as we develop code - the opposite way of what we're doing. Too many exercises Good balance Course was great! Would have been amazing if we had little faster exercises and more course content covered Very Good The course was great. There were a lot of fundamental C++ building during the demos, which I feel could have been improved with snapshots of pre-written code. Really patient and highly knowledgeable. Great T-Shirts too :) Due to release closedown and committed work, I won't be able to start tomorrow. Will definitely change the way I work from the next project that I get Time investment from management is a huge challenge for a legacy code that we have Show
TDD for Embedded C++ Excellent Much better Yes Being persuaded TDD is a better way to develop software and learnt how to do TDD. Good balance Good balance It would help to extend the duration of the course to spread out content more evenly. After some time, the ability of the participants to pay attention drops. Exercises can be a good break between presentations and demos Excellent Exercises are carefully designed. I appreciated them a lot Thank you for the course, it's career(life)-changing Yes. James went through a demo step-by-step on how I can apply TDD to my work. Time pressure allocated for each task, breaking dependencies takes time. But this is more of a issue with the planning. Show
TDD for Embedded C Very Good Much better Yes Applying the Crash - Pass algorithm to legacy code. I'd done something like this before (once or twice, as a toy/research example) with some anxiety whether I was even achieving anything in the process. This was great. Not enough exercises Too much presentation I'd recommend looking for ways to break up and alternate the presentation/exercise components into shorter cycles: the presentations are thorough and patient and generally great, but there's a lot of information to process and by the time I reached the exercises on the final day, I was definitely experiencing serious brainfade! Excellent James is great! The supporting media + PDF materials are nicely prepared, the delivery is clear and thorough, the active supervision in the exercise components was really helpful and impressive. No. The current projects are in a winding-up phase. But I'm prepping for the next one on the sidelines, and aspects of this approach are definitely going into the planning. Third-party integration and sheer volume of legacy code. Show
TDD for Embedded C Very Good Much better Yes Good balance Good balance Very Good Could have used an exercise on implementing in an existing code base that doesn't use TDD Excellent instructor. He came up with some great content and presented it efficiently and in a way that kept our attention! Show
TDD for Embedded C++ Excellent Much better Yes Your feedback on the exercises was great - it definitely consolidated a lot of the material we learnt. The combination of presentations and exercises so we could get the feeling of the TDD workflow was really good. Learning not to code ahead of the tests was useful, as was experiencing how designs would evolve as the test progressed. Good balance Good balance I am not sure - it was very good! Excellent The exercises were very good and well paced - the use of CyberDojo was really good. Excellent - I really appreciate the experience he brought to the training. I cannot start tomorrow - going on holiday! Will start when I return... While I am convinced of the time savings of the TDD approach (as opposed to the test and debug later approach), we need to communicate this to the product managers and the other members of our teams. Applying these techniques to a legacy codebase is challenging (this was covered in the course, but we did not have the legacy code workshop). Show
TDD for Embedded C++ Very Good Much better Yes This was my first time learning about TDD so everything was useful for me. Good balance Good balance I would have liked to see your approach to the exercises a little more. Very Good Better time allocation. Great public speaker and was very smart in the subject. Yes, now I see development in a different light. Hardware/network constraints Show
TDD for Embedded C++ Very Good Moderately Yes How to use some of the CppUTest features. Benefits of incremental development. The fundamental ideas of how TDD works. Good balance Good balance I liked the course, but I went in thinking there would be more discussion regarding how CppUTest works. Mainly because the wording from my boss/team was using CppUTest. He also mentioned TDD but it was used interchangeably (so I assumed). I had an idea that we'd discuss the features/framework more so about CppUTest; instead we did more TDD methodology. This isn't a flaw in your course, but a misconception on my part. You had us watch a video, which was the instructor with another class. There were questions and back/forth discussion during the video from the audience that I could not hear. It would have been nice to have those questions repeated by the instructor, or put up on the screen in text. Good I will say the first day, making the circular buffer, was more so spot on for me. The time spent was used to really focus on TDD methodology while introducing CppUTest. I felt like I spent more time trying to figure out the code than learning CppUTest or TDD on the 2nd day. Especially with the modern C++ concepts. I'm an embedded guy, and I do write in C++ but I'm weak in modern concepts (which I now have on a list of things to learn). I got a little lost with mockups. Conceptually I understood it, it was more figuring out how to get the error conditions to occur in the flash driver example to do more mockups. I know there was a hint video to walk you through, but it was too late by the time I started to reference it. Pretty straight forward, and knows his stuff. Yes, it's already started where I'm at. None, they are already here. I'm new and trying to get on board with them. Show
TDD for Embedded C Good Moderately Yes Clarification on the TDD approach. Good balance Good balance I think it's good as is. Very Good They are fine as is. Maybe reiterate that the hints and demos are there for getting over the initial starting hump. Yes. It's already implemented at other places in the code base. Refactoring code is not high on priorities Show
TDD for Embedded C++ Good Moderately Yes Good balance Good balance Good Show
TDD for Embedded C Very Good Moderately Yes That there isn't anything novel, hard, or expensive (like simulators, emulators, etc.) that has to be done to "do" TDD for embedded - that I can use proven software engineering concepts - TDD and programming to interfaces (i.e., test doubles) - to achieve off-target testing (with caveats - more in other feedback comments). Too many exercises Good balance I'd like to see more focus on the concepts (why I chose "Too many exercises"; really meant "not enough concepts"), since I came away not knowing the difference between "fakes" and "doubles". Sure, that's what Google's for, but why be in a class with homework for three days and still not be clear? I can't explain to someone the difference or know which one to use in which situation. I found an article from Uncle Bob, which I'll read so maybe not a huge deal, but you could improve the class by adding a bit more clarity by more clearly defining the test doubles and when to use them. Also, sometimes concepts from class and/or homework felt a bit scattered and/or without context, even if they are good to teach professional software engineers (e.g., code smells is good to know about, but kind of tacked on at the end). Good The exercise topics were good, but I did run into a couple issues days 1 and 2 that weren't pertinent to learning the concepts of the course and that was frustrating. Maybe it was just me, but a couple hints on macros for those less-experienced could help people like me. On day 1, after you demoed the initial tests to us (and which I completely followed), I was under the (false) impression that those tests were already being provided to us and we would pick up from there, so I removed those sections. I eventually recovered after some time, but then missed the point of the "pair programming" concept (i.e., macro to comment-out undeveloped tests). On day 2, the 1st part of the exercises went without a hitch, but I got syntax errors doing the refactorings as instructed to make the multiline macros. I can apply concepts like making lightweight lists of test ideas from a "specification" (e.g., requirements doc, code, etc.) - I did that yesterday vs. normally designing "all" the tests up front, so being more agile! I can also start using the test doubles concepts (even if I don't know the difference between 'spy' vs. 'fake' yet). I don't know about true TDD for embedded, though. Still need to use our custom test harness where a build and deploy to the HW takes ~60-90 sec. I can make my tests fail before I fix or create code - step in the right direction and improvement. But I'm not sure how we can create completely off-target unit tests the TDD way, eventually deploy new code to the target, and have a way to unit test that code on the target, if the unit tests were just "regular" unit tests (vs. in our custom harness). Not sure how the unit tests would talk to the target at that point. Can't just run them on it, either. Both technical (see above) and cultural (getting the smaller (embedded) and larger (project) team onboard). I've been a big proponent of TDD for years (on other projects) and my current project has been experiencing great success being agile and using Scrum, but one of the few technical processes associated with those frameworks that they never mention or use is TDD. Show
TDD for Embedded C Very Good Bring it on! Yes reinforcement of the small steps approach and to try not and tackle too much at once and also perhaps to not get caught in doing too much mocking. Good balance Good balance I would have liked more examples/exercises regarding methods of low level TDD and where trainer felt it made sense or did not make sense to TDD. Perhaps more examples of pattern or anti-patterns of how to shim in TDD close to the hardware, etc. Very Good overall not a lot of comment, at times I felt I needed to hold back and just do exactly what was mentioned for that item/test and then sometimes comments by instructor were it could have been more optimized, etc. But since I was purposely trying not to go farther than needed I did not do that, so perhaps some clarity on where/when to refactor. No issues, seemed knowledgeable and well spoken, could be understood and was obviously passionate about the subjects. Yes, was already using but now hopefully have more practice and context Personally I don't code there but besides that I think the biggest issue of getting folks to adopt will be just getting them exposed to it and willing to try, more cultural than anything. Show
TDD for Embedded C++ Very Good Moderately Yes The concepts of TDD Too many exercises Good balance Very Good Show
TDD for Embedded C Excellent Bring it on! Yes The mindset of test driven development Good balance Good balance This course is highly organized and very well developed. Maybe more feedback on expertise and do some peer programming will be really helpful. Excellent Maybe more peer review for exercise It is an amazing training and definitely mind blowing especially for me just graduated from college. That is some knowledge and skills that really useful and should be taught in every university. Yes, I will start today. Definitely need more practice to get deeper understanding Bring the unity test for legacy code. Also, my team used Tasking VX compiler and can only run on Windows. It maybe challenge to apply test framework. Show
TDD for Embedded C Very Good Much better Yes The emphasis on small incremental steps while writing code. I always tried to get a minimum skeleton working first but even that was typically a lot of code written all at once. Good balance Good balance More discussion would have been useful but that is true for most online classes I have taken and I don't have any specific suggestions to improve it. The instructor often paused and asked if there were questions but was answered by silence, no ideas about what more he could have done. Very Good One or two more challenging exercises to work through as homework would have been useful. Schedule pressure. Show
TDD for Embedded C Very Good Much better Yes I had tried using the CppUTest mocks before and I couldn't quite wrap my head around what I was supposed to be doing. I definitely have a better understanding of how those work and how useful they can be for drivers. Good balance Good balance It may have been due to the remoteness of the class and the varying skillsets, but it seemed like a lot of subject matter for only 3 half days. I don't think there was anything I wanted covered that wasn't, but I couldn't tell if we were skipping things or not. Very Good Having read the book years prior, the exercises were very familiar, a little too familiar. Although I realize that is maybe more the exception than the rule. James was very knowledgeable on the subject matter. I don't have anything negative to say. Yes (already have). I read the book probably 4 years ago, used it on a project where I was the only developer and don't think I would have been successful without it. After that project, I setup CI and automated unit testing which has caught many problems since then. Only myself and one other developer have attempted to actually use the tests to drive the design, which has worked out well. I have made the decision personally that whether testing is supported by the project or not, that I'll be writing tests for the code I write. One developer has flat out said they don't have time to write the tests as a senior developer. They will often write code, then assign someone else to write the tests after the fact, even though they have said multiple times when they have written tests that it's caught errors and they were surprised at all the mistakes they made. One other developer prefers to do things their own way, eschewing the framework in place. Bottom line, it's a cultural thing. Without everyone taking a course on it and not able to force them to read the book, there's bound to be limited acceptance. Show
TDD for Embedded C++ Excellent Much better Yes The TDD process, how tests are written and run systematically to find bugs as soon as they are written. Good balance Good balance Sometimes I think we did too much watching the instructor code/debug. However, I understand this was probably useful for others. Excellent Engaging speaker who is obviously passionate about TDD. Yes, current project enables me to write unit tests immediately using TDD as we already have a googletest framework. Lots of dependacies in the code. Show
TDD for Embedded C++ Very Good Much better Yes Importance of unit testing and surprisingly how easy it can be. Good balance Good balance Found it a bit hard to concentrate some times, I would personally like a few more short breaks. Because they were afternoon sessions for us in UK (2 - 6pm) I preferred an early finish so didn't suggest it during the training sessions. But thinking of it now, short breaks would have helped. May be asking the group might be a good idea. More of a lesson for me rather than for James, becaue they were afternoon sessions, ended up working for the first half of the day which made it even more stressfull. Including homework etc it was by no means half day training. Very Good I was slow to start on day two and three exercise, could just be me as I need to understand the overall system before i can start working on it. May be a warning/note that you 'must' watch the scheduler training video before the exercise would have helped. For the Flash Program, again it was not clear to me straight away what needed to be done. Overall may be the exercise descriptions can be made more clear. Loved the dojo setup so we didn't need to worry about the setup etc. How you can track attendee's progress and offer to help if you think they are stuck. The course material is very rich and i have learnt so much. I intend to start today :) NA Show
TDD for Embedded C Good Much better Only if improved Benefits from using TDD and how to use it for new projects and for legacy codes Not enough exercises Good balance I think this course should have a few more days. I feel that TDD is very extensive, and maybe a few more days could have cover more stuffs Good Exercises from scratch could give a better familiarity with the used tools, in this case CppUTest. Could be even better if the course starts by setting up the development environment Lack of time or interest from business Show
TDD for Embedded C++ Excellent Much better Yes As a beginner, I don't know how things should be done correctly. I would like to learn the good habits in the beginning of my professional carrier. TDD is definitely a technique that I will always apply if I can, knowing that is the right path. Other topics I really liked: -Test code as a documentation. -Make small changes to the code and let the compiler helps you. Good balance Good balance I had a distracting desync issue in the last 15 minutes of the course, but it could be caused of our vpn. Very Good I would like the 2nd (light scheduler) and the 3rd (driver) exercises to be a bit more guided like the 1st (cyclic buffer). It was very easy to follow all the explanations. Yes, we are already applying in our current project unit testing for all the components. Including TDD in my workflow should be natural. Show
TDD for Embedded C++ Very Good Much better Yes how to choose next test in TDD cycle. Good balance Too much presentation I'd like to try integration with hardware. and then think about whole process and how effective mock and TDD Very Good - really good. - release next test style(moving line..?) a bit confuse. no other good way in cpp? like @ignore, xit like that. - want to TDD multiple file(class) case. want to learn whcih part should test, start from which module. Thank you so much, very fun and learning a lot. I really appreciate open online class. yes. I apply to my work testing step idea. I share and practice with my team what I learn Show
TDD for Embedded C Very Good Much better Yes The overall process of TDD with practice writing and doing tests. Having feedback on that practice. Not enough exercises Too much presentation Doing a bit more with the exercises such as setting up the mocks, fakes, and spies. Having to set them up would be useful practice. While I think I understand when mocks vs fakes/spies would be useful, having more examples of mixing both to show the difference would be useful. Very Good Setting up mocks, fakes, and spies as students in an exercise or students doing it at the same time as they are being demonstrated. More interaction with them would be useful. More individual feedback on how our tests are structured or if we are doing too much or too little in the incremental testing. Yes Show
TDD for Embedded C Good Moderately Yes I learned about the value of building code through small, incremental, and testable steps. Good balance Good balance Include instructions for setting up your own environment so students can continue writing tests after the course completes. Good The circular buffer exercise was a good first step into TDD. Going from that into the light scheduler was a big jump. I'm glad all the fakes were already done, but it was a little confusing where they came from or how you would make it yourself. We got to that a little bit in the flash driver exercise. I would have benefited from a little more explanation about fakes before diving into the light scheduler exercise. This information was available in one of the videos, but it wasn't available until after the exercise. None No - I could start writing tests, but I don't have the environment setup to start execution. I could have benefited from a video or tutorial on setting up the environment. You mentioned this used to be a prerequisite for the course before cyber-dojo. I'm glad cyber-dojo is there and it's super userful for the class, but maybe including the other instructions would help students after the course. Getting others to buy in and change their mindset on code development. Show
TDD for Embedded C Excellent Much better Yes The thought process behind how to write tests. Good balance Good balance N/A Excellent N/A Did a great job. Yes. It might not be perfect, but the class prepared me to get started. Getting over the initial work of getting everything setup. Show
TDD for Embedded C Very Good Much better Yes I really enjoyed the device driver tdd application. Things clicked for me, and I would like to take this approach in my future driver development work. Too many exercises Good balance I would say that the exercises could be shorter to deliver the important concepts. I loved the flash driver programming example, which felt like an adequate amount of time. Maybe it's just my own personal preference. The final demo that you did today was a bit difficult to follow. Perhaps it might have needed a different example or perhaps the feeling comes from a lack of any hands-on time with a similar task. Finally, I'd suggest muting a few settings in Webex if you are asked to use that software in the future. There is a Participant menu above the video. There you can set "Mute on Entry" and disable the "entry and exit tone" so we don't hear people dropping in/out of the presentation. Very Good I think the first two exercises could benefit from some extra hand-holding in the beginning. I just felt a little slow to pick up the pace and get comfortable with something new. I stated "too many exercises" above, but perhaps I should restate that to mean the exercise was a bit long. Chopping up the light controller exercise or circular buffer exercise to two separate, shorter sessions could have been better, IMHO. Maybe that means "too few exercises." I realize there is much to be desired with the virtual classroom for some people, but I thought it was better than most webinars that I've attended. You did a great job interacting from a distance and keeping us engaged. The cyber dojo is awesome for test-driving things out, and I also liked the anonymity of the avatars. I have always learned by doing and don't have an extensive training in C/C++, but I can hold my own pretty decently. In the dojo, I could make all the silly syntax mistakes that I needed until I shook off the coding cobwebs. This made getting help much less scary in front of my peers. You obviously know your stuff, which is pretty important. Thanks for not waving your expertise in our face for four days. Some training sessions are more about self-promotion than actual teaching of new concepts. =) I think I'd like to see how we can implement this in our workplace. I haven't looked at CppUTest yet, but I'm hoping it's easy to get it set up and running. Maybe I just hate setting up a new IDE and getting the parts to talk nicely to each other. Working with legacy code is obviously a big chore, as we saw today. Sometimes we get mothballed projects that have to be resurrected for a season or two, and then they go back to the warehouse to collect more dust. Show