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 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
TDD for Embedded C++ Excellent Bring it on! Yes The process and mentality of using TDD, with hand-on usage of a TDD framework. Good balance Good balance Not much. The online course aspect was challenging. I would have preferred a classroom. Excellent Good at presenting. Yes. At least with getting a TDD environment setup with one of our embedded development environments. We need our software leads and a critical mass of developers to understand the process and benefits. Show
TDD for Embedded C Very Good Moderately Yes I think the examples of constructing tests that only follow a single path through the code were the most useful. The demonstration using fakes and spies will also be very useful. Good balance Good balance The course had a heavy emphasis on changing the habits of experienced programmers. (Which it should in most cases.) However, as someone newer to programming, I occasionally got hung up on language/syntax related issues which made following along with the important stuff a little more difficult. Good While we were supposed to take it slow and figure them out, the exercises felt very rushed. Having a video of the instructor checking in on people made it difficult to focus. Maybe give a link to a cyber-dojo exercise before the course begins so people can get familiar with it. I have already started. I just have to get in the habit of doing it. Fortunately, my workplace embraces this change and wont hold us back. Show
TDD for Embedded C Excellent Much better Yes The basic TDD "state machine", and I for the first time really understood the paradigm shift that TDD requires. I'm super excited to try TDD now! Good balance Good balance The various topics on the last day were a bit much for me to truly absorb. Excellent Maybe provide some intermittent solutions half-way through the exercises. The instructor did post video solutions as needed to help students along, which was great, but sometimes having partial solution *.h/.c files mid-way through the key exercises might be helpful. Outstanding instructor! This guy really knows his stuff not just from theory but also from years and years of real life experience! Very impressive also how well the instructor managed a huge class online. I had all kinds of problems the first couple of days (including microphone problems) to wrap my head around the concepts and the instructor worked through all of this remotely with me, which was awesome. After the second day and watching the supporting videos, I finally got the concepts. Very patient, knowledgeable, and professional instructor, probably one of THE BEST instructors I've every had! I could start with basic TDD, yes. The more advanced concepts will take time to learn. Probably getting buy-in from all the other developers on my project to give TDD a try. Show
TDD for Embedded C Very Good Much better Yes The most useful aspect of the course was actually getting hands on practice with using TDD and the feedback from the instructor. Good balance Good balance Have the class in person. Although it wasn't your fault that we are in the midst of a global pandemic. Very Good The flashdriver exercise was better than the other 2. I felt lost during the first 2 exercises but I thought the flashDriver was more structured and guided. Maybe it's just me. I like the added videos online but I felt like it was extra work for me to watch the videos. I would have like to have the set time for instructions and videos. that way I don't have to remind myself I have homework. yes. I started implementing the methods after reading the book although it was more in python. Show
TDD for Embedded C Excellent Bring it on! Yes With TDD, errors will be found immediately as code is written, and in the process, a safety net of tests is built so that bugs will not be introduced when the code is later modified. Good balance Good balance I think SOLID principles are very important, and the explanations could be better. However, this course was about TDD, and maybe SOLID deserves a course of its own. Very Good Nothing comes to mind. I thought they were fun. The instructor did a good job adapting his presentation to WebEx. No. I don't work on Fridays. However, for my next embedded development task, I will be using TDD all the way. Maybe the extra time to ramp up our TDD skills, but it probably won't be a problem. Show
TDD for Embedded C Excellent Bring it on! Yes The TDD development process (in combination with learning surface level of tools like CppUTest/fff/etc) Good balance Good balance I think the wealth of resources presented on your website will help support a change in software development habits going forward. The concepts of TDD were clearly explained. Some of the exercises had some ambiguity to the path forward which I found distracting to the goal of learning/practicing TDD on simple coding exercises, however many probably did not feel this and perhaps some of it was introduced in user error! Seems to provide a great jumping off point to change development practices to TDD (though courses teaching habits are hard to evaluate directly after without time to implement these habit changes). An exercise on the last day would have been nice, but lots of material was covered. Very Good Possibly remove subtlety from instructions. The risk reward of someone missing it and floundering for a bit vs understanding and making more lasting connections through discovery :) Very knowledgeable of subject matter. Open to questions/discussion at all times. Fun sense of humor. Kept class moving well. Yes, personal project to scratch my programming itch (lots of hardware development currently at work). Will begin planning new project software using TDD principles (mock drivers, software dev before boards back, etc) when time permits. Finding and getting comfortable with a C Unit Test harness. Setting up Jenkins for simulated environment, board environment, adjusting coding habits. All of these are on me, I do not have resistance from colleagues/management. Show
TDD for Embedded C Excellent Much better Yes iterative development, speed of testing, finding minor bugs such as typos, then forcing structure. Good balance Good balance The biggest challenge, timing of the training due to the global impact of COVID-19 and our company's limited adoption of web conferencing tools. Added additional learning curve to participants and instructor. Not a ding on the course, but a challenge to overcome that was handled adeptly. Very Good Exercises and examples are hard to construct due to wide range of developer experience (beginner to expert). With that being said, is there a creative way (without severe dilution) the exercises to student capability. Let the student select the level of challenge to take on to gain the experience in TDD without the burden of also having to be an expert in the language of choice. Pair programming during the exercises certainly helps and might be the best answer here. James manages the hands on experience in a creative fashion. Remotely monitoring student work and raising the flag when the student drifts off the wrong path! already started, to some degree. applied concepts to on target testing for new features to legacy code. standing up new team, new work, and integrating TDD from the start. working in IDEs, building automated testing capability/infrastructure. championing the TDD process over 'how work normally gets done', getting buy in from management and technology partners Show
TDD for Embedded C Excellent Bring it on! Yes Lots of great material, but I liked seeing how a legacy code file was broken out to work with a test. Good balance Too much presentation I only say too much presentation because the course was hosted online. I think if the course was hosted in person there would be more discussion. Excellent Nothing, easy enough to be completed in 1-2 hours, but hard enough to learn a lot. Instructor was great. Yes! I started on day 2 of the course. Huge legacy code base. It is going to take a lot of work to get things testable. Show
TDD for C++ Very Good Moderately Yes TDD and how to practice it while writing code. Good balance Good balance Little more explanation on exercises used in the course. Add some activities or exercises to support group discussions, thinking and problem solving. Good By explaining in detail about the exercises and code (relationship between classes etc.). Yes. Also, I already knew the TDD concepts and applications before attending this class. Mostly working on legacy code. Currently not much unit tests coverage. Also, not good infrastructure in-place and push for quality and automation. Show
TDD for C++ Very Good Much better Yes I understood the cycle of TDD. Initially I used to write code and then write unit test Now my whole view point changed, RED->GREEN->REFACTOR Good balance Good balance (1) People are busy, so expecting them to go through 1 hour of video before the course becomes challenging. They are distracted. The time they commit to training is what they can spend. The training time can be extended to go through the videos (2) The requirements for circular buffer could have been explained. Again expecting the trainees that they gone through the videos and understood the requirements would be difficult. 10 minutes could be spent in explaining the requirements of circular buffer (3) Case studies on of how TDD helped productivity/performance would be more useful. Excellent The exercise were good, simple to be done over web. It was perfect example No comments I have started doing TDD right away Mocking free functions, singletons Show
TDD for C++ Very Good Much better Only if improved - overall philosophy was a great reinforcement. The value of TDD has been made crystal clear. - I particularly enjoyed the live coding/presentation of adding unit tests to legacy code (although a bit lengthy). Too many exercises Good balance - cyber dojo software was cool, but unfamiliar. Some participants were being put on the spot at times, which probably led to embarrassment among peers. - sessions of James coding, adding tests, and talking through it... were too lengthy. Got the point well before completion of the exercise. Make them simpler. Get to the point sooner. - no lunch break, and no break at all on day 2 (besides, "take your own break during the exercise, if you need it"). Fair - we were encouraged to write failed tests, or code that doesn't compile, and then go back and fix - I don't work that way. And our build times don't allow for such tight fail/fix iterations. Consider this when instructing others. - (#1 peeve) There should be much less emphasis on the ability of participants to code the classes (problem solving skills) in the exercise, and more on the process for writing tests. I like solving problems. But I am a very methodical, analytical thinker. Solving problems in this environment doesn't work well for me. I solve problems independently. Sorry, that's just how I am successful. This isn't a problem solving course. It's a test-driven development course. Make it that. Make the problems ridiculously simple. Make the course about test development ... not problem solving. - James was clearly experienced as a coder and presenter/instructor. Professional, and with a good sense of humor. - I believe James sincerely wants to help all developers to embrace the TDD methodology - personally I did not need a lesson on duplicate code, or refactoring, or how to add a parameter to a function. I beat this drum every day. So, I at least appreciate James reinforcing the benefits for my peers. I'm sure that sounds arrogant, but I'm in complete agreement on keeping code clean. I am just not sure I saw the direct correlation between clean code, and TDD. Tomorrow, literally? No. Next week, possibly. Many deliverables stacking up while on training, which simply are not coding related. I.e. even if coding related, probably aren't in that foundation layer where unit tests apply. I'll be lucky to encounter a use in the next month. Don't get me wrong. I'm drinking the cool-aid. And I will apply when appropriate. See previous response. Show
TDD for Embedded C Excellent Moderately Yes How to change my main focus from product features to firmware functional failures what need to identify and build test cases for there failures rather than functional test. Good balance Good balance Test Driven Development could be the solution to many bug fixes followed by firmware release so this cause improved my though pattern. Very Good I could not get into exercises right from the start since I was not families with test development environment but later get in to tools and concepts. Writing test is inverse thinking for me as you first understand what is return value of the function not what needs to pass into the function. Good communicator.. give more example projects will help to understand your concept of TDD Legacy code need to find a way to improve with TDD, I am sure I will find a way to start sooner that not later. Time for firmware development in Active Sprints need to consider these approach of code development and code review based on TDD as a must criteria Show
TDD for Embedded C Excellent Bring it on! Yes Develop tests one at a time. Good balance Good balance Less disruptions during presentation (i.e. no need to adjust presenter image size during the presentation, and the smaller version of you is better for me). Excellent More guidance initially on how to do certain things to get over the mental blocks. That guidance could simply be in the form of a quick reference guide for the various types of testing patterns. So nice to have such a seasoned trainer and someone experienced in the subject. It seemed that no matter what curve ball questions were asked, you had heard them all before and had a great answer which typically included pros and cons about various approaches. Maybe. I don't have an IDE setup yet TDD. My normal test development process is simple code editor (scite) and Make and GCC. Getting common unit testing framework adapters for each code base to use when touching the various projects each week, along with activating CI for them (some CI is already active). There are some using CTest, some using Unity, some using ztest (zephyr os project). My colleagues taking TDD class liked CppUTest and I like the code coverage of it. Show
TDD for C Very Good Much better Yes That TDD is done in small iterative steps. Before the course I thought TDD involved writing all test cases before developing any production software. This has taught me that there's a need for a fast feedback loop for tests and production software development. Good balance Good balance The refactoring video has large portions of it where the audio is very poor. Every time you walked to the board in the video the audio became almost impossible to hear. Very Good It took me a bit of time to find the flash driver flow chart in the slides .pdf before working on it. If there was a way to put that in the cyber dojo instructions it would make it faster to get started. Yes. We've already got a unit test framework setup using google test/mock. I'm going to try applying the concepts from this course in my next sprint. The feedback loop between unit tests and production code is a little bit long. Show
TDD for Embedded C Very Good Much better Yes Well I learn: 1)To write test for my code then let test drive my code. 2)Not to analysis suffer from analysis paralysis, let about the problem while you TDD you code. 3)Work in small incremental steps/Slice the problem. 4)Slow down do go fast. Why am I in a hurry to write bugs that's going to take me away from the things I love. 5)Because I am a jack-of-all-trades and don't code as often as I like, TDD is a must! Good balance Good balance I don't know if everyone would enjoy it (I think you have done this before), but I it would be eye opening to assign the circular buffer exercise prior to the course. Then the students can see how different it turned out by doing TDD. Finally, as a bonus or on the last day, have the student test the "legacy" circular buffer and improve it. Excellent For someone like me that do not code all of the time it would be helpful to introduce the exercise the day prior to when the exercise will be done on class and perhaps have a similar bonus exercise assigned as homework with the assigned video of the day. I enjoyed you delivery, anecdotes, and jokes. Yes, but: I will start tomorrow, but with home projects and hubby type of stuff. I currently have no FW work that I can do remotely. The challenge is that in my organization change happens, by design, organically. In other words, someone changed the way they did things and improved their process; then someone else notice the changed and finds it useful or better than the status-quo. So, change happen slowly. However, that why I attended the class I so the value of the method in a colleague’s work. Show
TDD for Embedded C Very Good Much better Yes The TDD process. Before this course, I had experience with writing tests, mocks, stubs, code coverage, and other technicalities. This test was extremely valuable in emphasizing HOW to implement the process of writing tests to drive your programming. Good balance Good balance I think by having an exercise on refactoring legacy code via TDD, or on adding tests to legacy code. Very Good I think the exercises were quite good. I would like one additional exercise where we are given completed code, But there are no tests and our job is to add tests. One of the things I have not experienced from this course is taking existing code and adding tests to it. We highlighted this in the slides on day 3. Very personable and easy to interact with. Good job! I plan to start this afternoon! I'd like to try using TDD with a new feature I must add into my code this sprint. I think the hardest thing getting going is adding tests to existing code that has many dependencies. When we've begun adding tests in the past, we were turned away because of all the dependencies that must be either mocked, stubbed, or cleaned up. This initial time sink is a big challenge, but one that I think would be worthwhile to solve. I hope to take on this role of pushing our team to begin resolving these dependencies, so that our code has tests. Show
TDD for Embedded C Very Good Much better Yes It is easier to keep the code working than fixing it after you break it. I often make my modification in batch mode and then have to fix all the compiler errors for the next hour(s). So seems sensible to reduce the pace to gain in overall speed. Good balance Good balance The chat questions could be handled a bit quicker. But I don't know what are the solutions offered by the tool used, so maybe it is not that much easy. I could have asked my questions on vocal so that's on me too. Excellent Yes, I'll really try to apply more TDD. Even for prototype. Lately I had to do some prototype to let other person tests functionalities of some hardware and the amount of time I lost at debugging those prototype was really frustrating. I'll need to practice in order to become proficient in TDD to keep up with it even when deadlines are approaching. Show
TDD for Embedded C Excellent Much better Yes the use of mocking Good balance Good balance The video setup is really nice (to see you and the presentation) but it would be nicer if it worked all the time. Very Good In the schedular I only discovered at the end that there were clear tasks about the tests to add at the bottem of the test file. During the exercise I only looked at the instruction which I found to be vaguer. No, I think I need to first integrate the test framework so I can run it on/off target without FreeRTOS Get the test framework to work on/off target Show
TDD for Embedded C Excellent Much better Yes The general process and thinking associated with TDD. The application of those ideas was also very helpful especially since they were followed with good hands-on exercises. Good balance Good balance I struggled a little bit with the second days lab material. The instructions were generally clear, but it was sometimes difficult to get in the TDD mindset of where to start. Very Good Fantastic! I'm going to start tonight by setting up the environment. I'll then run through the labs again to get a little more experience under my belt and then try these techniques with some high-level application code that will be starting soon. Patience and taking the time up front to apply them. Show
TDD for Embedded C Excellent Much better Yes How easy it can be to write effective tests. Good balance Good balance Can't think of anything at the moment. Excellent Can't think of anything. Jokes and light-hearted nature were great; very relatable. Yes; I work for a scientific institution, so we don't have as many "product" deadlines and rapidly changing requirements, but rather expected uptime/success rate for our platform. Getting a single class/module of my existing code base into the harness is going to be a challenge. Show
TDD for Embedded C Excellent Moderately Yes I learned that we should not run away from the idea of refactoring, rather, take a more controlled approach based on first setting up tests, then make changes. Good balance Good balance I will need to go back though the course material but at the outset of the class I had not (other than the pre-requisites) has any real concept of TDD and how it directly relates to refactoring. Maybe some reading material on that in order to kick off that thought train would help. Very Good -if- there was more time, it would be great to see how one of these builds were setup. Very easy to listen to, nice work! I need more practice in order to solidify *next steps* in my minds We have multiple code bases on multiple compilers on multiple IDEs. Fun. Show
TDD for Embedded C Very Good Bring it on! Yes That TDD can make you a lot faster. That it is a way for me to be more structured about my work - it gives me a good reason to be. Good balance Good balance I think the course is very good as introduction for TDD, but I would like to see some more advanced topics covered (e.g. an example where thread safety is a concern). It would also be nice with some more coverage on QA in general and how we achieve a satisfactory quality of the whole product with different kinds of testing and other QA mechanisms. This would make it easier for me to see where I can use TDD to improve and spot other areas where we may be able to improve in relation to QA. Very Good I like that he is very chill with a good sense of humor and clearly knows his stuff. Also good at keeping focus on the important parts and not spending too much time on things that are interesting but not relevant to all course attendees. Sometimes it can be a bit hard to deduce whether he understood an attendee question or not, so spending a bit more time talking about questions from the attendees in general might be better. This could be done by asking if other people had similar questions, asking about the context and just increasing the interaction with the crowd a bit. Yes! I have already been doing it, now I'm ready to do it even more. Previously it has been an issue that not all members of the team have been familiar with TDD. Now all members of the team have attended the course and should be much more ready for it. We have legacy code, where it is very hard to introduce TDD. It can be hard to find the balance between maintaining old stuff and creating something new based on current knowledge. Show
TDD for Embedded C Excellent Much better Yes I had some prior TDD experience, but it was very good to get a recap on the testing levels and the refactoring of the tests Good balance Good balance I believe that there is an art in finding the correct balance between online activities and the videos. The problem is that the balance probably varies from course to course. I experienced myself that the amount of time I had available differed from day to day. Maybe it should be stated very clearly that the course is full time all days ;-) Very Good Thanks for an inspiring course Yes. -although I have to bring the turnaround time down. - bringing the turnaround time down. - Getting everybody else to see the light across project groups ;-) Show
TDD for Embedded C Very Good Bring it on! Yes - While doing the exercises, I noticed that changing and refactoring code was not scary any more. - Try to eliminate the habit of debugging. - How to test hardware. - Some solutions are dirty when working with legacy code. But it's necessary. - How to start writing test to your system was challenging. I think ZOMBIE rule is going to solve it. And more Not enough exercises Good balance - Adding an example for working with legacy code would be great. (I know that is challenging) - We have been introduced to concepts like test doubles, mocks, fakes, spy , null object ...etc. Adding one or two examples of these concepts would be helpful. It does not have to be 1 hour exercise. it can be quick exercise. Or James does an example of one or two of these concept. - The last hour of the first day in the course was not the most interesting. I don't remember now what we were talking about. - In the second day you talked about the importance of testing. I think that talk is great and the idea could be delivered in shorter time. You could use the remaining time to explain something else. Excellent The exercises were good. If I have some comments I will email it to you. After my organization agreed, I would apply it for new written code. Legacy code would need time. - Convincing the organization and the team. - For embedded system we would need Continuous Integration tool setup. It would need time to be comfortable with the pipeline of writing code in the testing environment until the code is in the hardware. Show
TDD for Embedded C Excellent Bring it on! Yes TDD approach catch bugs early and also help make good structure of code Good balance Good balance Some technical problems, like shaking video feed and such, may be reduced in future Excellent Maybe increase excercise count by have some excercises offline. Good Yes, but offcourse practice make master. So it is a never ending journey... Maybe some extra time is required to introduce TDD, at least in the beginning. And habbits have to be changed. Show
TDD for Embedded C Very Good Moderately Yes How to implement TDD in the code Not enough exercises Good balance Good Show
TDD for Embedded C Very Good Moderately Yes Concept of breaking complex functions into smaller testable parts and how useful that can be Good balance Good balance It might have been useful to have a "worked out" file made available for exercises. If it's better to delay availability 'til - say - halfway through the allotted time, then that's okay. My point: the concepts are really great but it takes time and deeper understanding to implement against concepts. It's sometimes tough to assimilate the concepts and be a "slick coder" at the same time. Having "worked out" examples readily available would have been helpful. Very Good As above, more worked out answer sets. Also, perhaps a quick class setup example showing "...on this tab, keep the diagrams for what you're working on, on this page the worked out answers, and on this tab the work area....you the student may want to go back & forth a bunch and we've got a limited amt of time". Something like that James is a funny guy who's got a very practical idea about what it is to do embedded programming. Yes, but the caveat is that one starts small and works it in. We've got a big organization that's very process driven and big disruptions are not accepted easily. Rigid process backed by people in authority Show
TDD for Embedded C Excellent Bring it on! Yes How to think about breaking a system down into testable components. Also how to use mocking frameworks like CppUMock. Good balance Good balance You could add an on-target CPPUTest module that requires attendees to implement their unit tests on embedded hardware (maybe a standardized eval board). This would help show how to maintain the off-target and on-target test runners, and show how results from one target effects another. Excellent Same as the course improvement, adding an on-target module would be interesting. James was extremely knowledgeable, and is quite effective at communicating these complex ideas. I had already started, but I'm better equipped to do a good job learning/implementing TDD. Getting my existing code base into test harnesses has been difficult, but I'm seeing progress. Show
TDD for Embedded C Excellent Much better Yes The process of writing tests before writing code and ensure the test fails before making it pass. Good balance Good balance I personally would like to learn more about designing a code architecture that facilitates testing, but that may be outside the scope of the training. Excellent Dealing with a lot of legacy code (code without tests). The hurdle to get that code under test requires a lot of buy in from management. Any new projects will certainly use TDD. Buy in from management and an understanding of how important robust code is Show
TDD for Embedded C++ Very Good Much better Yes about the test driven approach and techniques to apply Not enough exercises Good balance More time for exercises. Good More time and clear solutions. Sure. Show
TDD for Embedded C Very Good Bring it on! Yes Approaching the development of a complex task with very small steps Good balance Good balance I think the course is put together well and serves the topic as expected. I think there could be further added value by pressing the concept of TDD beyond the particulars of the exercise domain and into the general problem solving space. An example may be to consider how really any work that sets out to accomplish a task (design intention) is in fact Test Driven... as there must be a vision of the end product that operates as a setpoint whereby the error signal is continuously monitored to shape the intermediate products to the final form. The designer is constantly "testing" the current stage of the product against the goal, though these tests are not formalized in a computer language, they do exist in practice. TDD in embedded offers the context to articulate the tests as "shaping" elements, like a potter working clay and each revolution of the workpiece pressing against the "test" of the hands which are effecting the final vision incrementally. Very Good Better overview of the files in the CyberDojo exercises. For each of the 3 exercises, there was a good bit of time "getting oriented" and establishing where to do the work of adding code. I also found a difficult tendency to "code ahead" of the exercise, and while a great measure of this comes from the paradigmatic inertia I was bringing in, it could help to have a bit more heads up of the scope of the expected code, possibly showing an example of what would be too much code for a given stage. Personable and enjoyable to spend time with, and successful communicating the information I'm already gaining benefits from being justified to start with smaller steps and not build so many monoliths. Bringing the "test" formalization to a higher realization in environments that dont have test frameworks. Show
TDD for Embedded C++ Excellent Much better Yes 1. How not to try to do to much at once. 2. How mocks work. Not enough exercises Good balance Nothing major. The only thing I can think (and its a nitpick) of is that the audio could be improved slightly. Excellent I would like to have a little bit more. Really professional and competent. I was really surprised by the instructor's skills, not only technical skills but teaching skills too. Yes Sometimes its hard for us to test our graphical layer since we are using opengl and didn't take the time to add the test infrastructure at that layer. Show
TDD for Embedded C Very Good Much better Yes Writing test cases such that they are driving the development process, and not all the way around. And also various types of ways that TDD can be implemented for embedded development Good balance Good balance It would be useful to have access, and be able to get familiar with the upcoming exercises before the live session (or maybe if you could provide some preliminary info to get us prepared for the exercises). I think that this way it could be easier for people to follow and to be able to complete the exercises on time Very Good Instructions could be improved/more detailed, and also pace them a little better (make the pace a little slower) In my organization we are already using the principles and practices of TDD The main challenged is that it's not always easy to apply these techniques to legacy code Show
TDD for Embedded C Very Good Much better Yes TDD, mock, CHECK Not enough exercises Too much presentation Present an iternary for the 3 day course, listing all the topics so we can review in advance Excellent Show
TDD for Embedded C Excellent Much better Yes Taking the small steps to ensure the test worked, as well as the code. that keeps you on track for writing the best code. Good balance Good balance trying to get more people involved could be good to get them thinking. Very Good i would also like more challenging task on the last day. could be because i have written a hardware driver before though. I am looking for a unit test that can provide useful feedback to us the programmers as well as being able to show our boss that it is useful and we are making progress. I am leaning towards unity since it has cmock. yes, looking into applying TDD to New platform code time is critical. it is hard right now to show the usefulness of TDD since it can take longer to get something running. Show
TDD for Embedded C Very Good Bring it on! Yes TDD! :) It's also very helpful to hear others actually saying that modularization is worthwhile. Good balance Good balance Very Good There might have been more clues as to exactly what you were looking for with a given test. In our case, we were able to come up with the testing that was desired, but that's probably because we have over 35-45 combined years experience (and all in embedded systems). Maybe go back to your recordings and get some of the things you told the less experienced people to help them along and add them to the notes/instructions. James is a good instructor in that he definitely knows his topic. I never felt like any topic came up either with his presentation or things added by the attendees that he didn't immediately know an answer. I would like to have all of his examples rewritten using a published coding standard and not just his internally known one. This removes ambiguity and make things easier to read, etc. Perhaps using Barr and associates. I can start today; however, we need to agree on which platform we'd like to use here. This is because whatever we (the three attendees) agree on will be what we impose on the rest of our colleagues. I want to be able to get them as excited about TDD as I have become. Lots of legacy code. James went over this a little bit, but there was no example/workshop on this. Show
TDD for Embedded C Very Good Much better Yes TDD methodology. Felt the benefits of write the test first, code later. Benefits of keeping the code working while refactoring. Good balance Good balance Maybe adding a practical video, simple test and moving, that concept was quite abstract for some of us. That way we could come to the course with that first shock passed. We lost some time on the first launch test because we didn't have the correct tools, a list of the needed things on the preparation should have been enough to save some time. Very Good Hard to say! Very good, you like teaching, and seems you arrived to this method after daily work coding pain. The interaction with the attendance was great, felt really good. Nice last day's t-shirt! I am starting tomorrow Will have to hide from the managers while getting all this at least to the start point! Show
TDD for Embedded C++ Very Good Much better Yes Just how much test code you need to guarantee total coverage of your "code under test". Good balance Good balance Fix the damn server ;^) Very Good Good sense of humour, kept us engaged. Some aspects being used now, for example to beat people up when they leave an acceptance test broken "Wingman said keep to it passing...." ;^) Probably a bit of inertia, and a lot of legacy code maintenance. Show
TDD for Embedded C Very Good Much better Yes The new thinking approach we have to take in order to do TDD. Up until now we used to create and implement the functionality, and then, perform unit test. Now I see that we have to take the new approach we saw at class. Good balance Good balance Maybe have a docker or VM with the tools installed as plan B for what happened the last day. Very Good I will add more examples on mocking, or one mixing mocking + something else. Yes. I think I got the concepts. Maybe we need to prepare/adapt the framework to our current working tools, but we will start on it I believe the challenge is on making managers see the benefits on these so that they can be patient at the beginning. Show
TDD for Embedded C Very Good Much better Yes The unitary test write process and the philosophy behind the testing process. Good balance Good balance Creating a virtual machine (or similar) with the unitary test framework ready to work. Excellent I can't because we need an internal meeting to decide wich framework to use and if we need or not to run tests on final board. run tests on final board Show
TDD for Embedded C Good Moderately Yes TDD is an important software developmnet practice that can help to get the code built faster and with less bugs. Also understood that TDD can avoid the bottleneck of waiting for the target hardware. Refactoring theory. Good balance Good balance Good I need time for setting up the development environment. Thus I can compile and run tests like we did in CyberDojo Show
TDD for Embedded C Very Good Much better Yes Good balance Good balance Very Good Show
TDD for Embedded C Very Good Bring it on! Yes A new way of thinking about programming, and refactoring Good balance Good balance Its really great. The only thing I would improve is to have the test framework ready for the legacy code workshop. Excellent I can't think of anything Thanks James for this great course, we hope you come back soon to teach us more! Yes Starting with the first test and test framework Show
TDD for Embedded C Excellent Much better Yes Good balance Good balance Very Good Show
TDD for Embedded C Very Good Much better Yes First you list the tests you need to develop to prove the good performance of the feature and then you start developing the tests and your code. I never imagine that was the order for doing it. Good balance Good balance Very Good He made the course interessant even if we were sometimes not participating a lot. It needs to be think how to start implementing it, but I think step by step we will be able of doing it. As he said in the course, when there is a hurry in a project everybody is not in favor of TDD. Show
TDD for Embedded C Good A little Yes The overview of TDD system, unknown for me before Good balance Good balance It would be useful to combine tests in group with individual ones to be sure of the concepts. Very Good Comment above. He could have told in advance about the tool installation so as not to waste so much time the last day. The idea nowadays is not applicable to my current project because of deadlines and initial time to be friend of the tool. It can be interesting for coming ones. The framework and the deadlines. Show
TDD for Embedded C Good Much better Yes - How to look through all possible test cases for the system - How to use Mock modules Good balance Good balance Very Good I can if I use my simple test environment. It will take longer to set a proper test harness. Legacy code and having a proper test harness. Show
TDD for Embedded C++ Good Much better Yes I learn that we need to think the bets form to test the functionality before develop the code. Not enough exercises Good balance I think more exercises can improve the course Very Good I think the exercises are correct and so interesting Show
TDD for Embedded C Good A little Only if improved The procedure must be followed to apply the TDD methodology. I am pretty sure using TDD would reduce bugs. Not enough exercises Good balance It would be mandatory to advise the attendees to have an environment prepared just to apply TDD to their legacy code. It was impossible in our case. Good It would be nice to have the exercises for being reviewed after the training. The exercises must have a good intructions, because sometimes we were a bit lost. We should not have lost so much time trying to compile and test our code. No. I do not know yet how can I deal with the amount of depencencies of a real project. Be able to isolate each module to be able to test them properly. Show
TDD for Embedded C Very Good Much better Yes Testing complex files full of hardware dependencies. Good balance Good balance Excellent Not unit testing framework ready. Legacy code. Show
TDD for Embedded C Good Moderately Yes How to 'mock' peripheral calls in order to implement this for embedded systems Not enough exercises Good balance Too much lecturing, not enough hands-on exercises. Should allow option to work alone for large assignments (i.e. the 2nd day morning assignment). Everybody works differently and not everyone learns well in a group/pair setting. Also, pair programming is not common in many engineering settings (and I had never heard of it before). Slides won't be useful resource going forward because there's no organization to them. Would be more useful if it was split up by topic. More active lectures would be beneficial. The average attention span is only 15 minutes long! During the workshop the demo took too long and wasn't as useful for someone working on a different platform that the person whose code was demo-ed. I didn't feel that I had enough time to ask questions to truly feel comfortable integrating this concept into my embedded systems. Very Good More exercises for actual embedded system implementations (only did one of these before the legacy workshop) Very knowledgeable on the topic and helpful when answering questions. Spent too much time repeating the reasons TDD is beneficial--asked us to watch a video before the course that mainly talks about why to do TDD, then spent at least an hour each day revisiting the same concept. Felt like wasted time. Yes, but not confidently. I still feel uneasy about implementing this in an embedded system. Though I expect the textbook will be a useful tool in figuring this out. Lots of code reuse--would have to refactor most of the code to get it to be TDD-friendly. Show
TDD for Embedded C Very Good Bring it on! Yes I understood the "write tests first, get passing tests, and refactor" process, but I did not understand that it progresses in tiny steps. I now have a greater understanding of the iterative cycle, and how very incremental it can and should be. That part was lost on me before this class. Good balance Good balance There were times when the instructor talked about real-life experience, and that was invaluable; however, I think the course could be improved by providing "stand-in" code to demonstrate what the overall issue was, and how code was changed to overcome the issue, instead of whiteboarding and discussing. This way, we get both the real-life experience, the why via discussion, and the how via the code changes we can visually see and understand. Very Good I like the principle of ZOMBIES for coming up with tests, but when I was staring at the last exercise with no tests, I was a bit frozen on how to start. We switched between 3 different practice problems, and maybe it was changing between 3 completely different systems that led to my second-guessing about how to implement tests for it. Did I really understand the system, and how it should work? Did I understand how to test what I wanted but in the TDD framework? I was still thinking of tests that were too complicated and involved multiple steps. Maybe this isn't a bad thing - I can add them to my test lists, but thinking of the tiny incremental tests was my problem brought on by the newness of the entire approach. Maybe if the exercises focused on the home automation, just different parts of it? The instructor was funny, provided real-life experience, answered questions, and presented the information and exercises well. He did go off on tangents sometimes, but they were usually informative and contributed to the overall story. Yes. We've setup test harnesses before, but were doing DLP. Many developers were manually testing and saw no point to writing separate tests. I'll push forward this methodology, so that others may finally see that writing tests can be part of the development process in a fun way as well. Management is very open to anything that accomplishes the job, so they are open to trying new things and learning. Developers, however, span the range of "stuck" in their ways to full on learning and grasping anything. Show
TDD for Embedded C Very Good Much better Yes TDD methodology Good balance Good balance Take out the repeat slides. Very Good My highest priority task at the moment has no test framework associated with it. Show
TDD for Embedded C++ Excellent Much better Yes Make it fail first Good balance Good balance I am not sure. I enjoyed the course and felt it covered what we needed. Very Good Exercises are difficult to setup as they are probably very target audience specific. There was a little confusion on "getting started" with one of the later exercises, but getting us to work with members from other teams was very useful. Excellent knowledge of the subject and areas around it. Clear and able to present information in different ways to help overcome any confusion. yes, our team already employ TDD, so it wasnt a major mindset change. The stepwise approach to software test and development should reduce the getting started hurdle and remove the "uhoh need to write a test" stage. None Show
TDD for Embedded C++ Very Good Much better Yes A lot of interesting rules, specially Zombie, Dry etc. Good balance Good balance You may consider starting with a simple exercise where you ask the participants to just solve a problem in their own way (without TDD) for a given set of requirements, record the time taken by them to complete this task. modify some of the requirements in a way that they would impact or fail the previously stated requirement. Most of them would probably break it as there were no test cases for validation. Then ask them to do the same using TDD. This will give a hands on comparison of TDD and ordinary way of SW development. Very Good mock test exercise was kind of boring for me as I didn't use that before.And I am not a device driver developer, so it was slightly boring for me, you may consider using some slightly interesting(less complex) example in the future. It all depends on the audience. Overall it was a good experience. The instructor knows his stuff. Yes We are at the product delivery stage for one of main project, so finding time to write test cases could be difficult. No doubt, these test cases would be useful but finding a balance between bug fixing and test case development would be the key. Show
TDD for Embedded C++ Very Good Much better Yes Thinking of the tests more from a behavioral point of view. So far, I tended to pre-define my APIs and then write tests for each API. Also, it was useful to see how small the steps can be. Good balance Good balance Very Good I thought the exercises were good, with the instructions to guide along the way. I don't really have any suggestion for improvement. I can start going in that direction tomorrow, especially for the refactoring side. Most existing tests are not simple unit test, as we build in most of our software framework. I don't think I want to modify too much the existing tests at this point. But for the next new component I get to write, I will give a "real" unit test a go, and see how it goes. Show
TDD for Embedded C++ Very Good Much better Yes I think the most useful thing was to be able to apply the TDD knowledge in real exercises and recover the discipline for doing TDD I lost. Good balance Good balance I think the time at the end of the day could be better used. We started some exercises at 16:00 o´clock and I think people was already tired and one hour or one hour and half does not give you much to advance. Maybe more exercises could be done earlier in the day and leave this time to discuss stuff. Excellent I think exercises are well chosen. One Circular Buffer which should be easy and helps you to focus on TDD and not the problem. Then the flash driver stuff, which goes lower level. Any comments, all good. I think so, but depends on what piece of code. We have a lot of code that does not tell any story, even the tests are difficult to understand. Most of people here come from an electronic engineer background and tend not to abstract much. Then if you try to abstract they say it will hit the performance.I think TDD without good SOLID principles can be difficult as that quick loop iteration becomes a slow loop iteration. Show
TDD for Embedded C Excellent Bring it on! Yes How to start/approach coding in TDD. Good balance Good balance Maybe talk about how to approach more complex tasks in TDD (i.e state machine design). Excellent Can't think of anything. He knows exactly what he is talking about. Started already! Although have to finish some already begun work, so will resume then. Scepticism mostly. That some code can't be sufficiently unit tested. I don't have the experience yet to give them proper answers, but I hope through time it will change. Show
TDD for Embedded C++ Excellent Bring it on! Yes How to use cppunitest. Some of my team use it, but I have not used it for my own tests, so I will for future code modules I write. Need to think more about how best to apply to legacy tests. I have come across most TDD and refactoring concepts before but it is always good to revise these things. Work in smaller steps. Good balance Good balance I felt the balance between listen/discussion/exercises was about right Very Good Circular buffer was a good exercise - it is in fact the C coding test I give for interviewees! Flash driver, interesting but less useful, need to think more about how can apply to our drivers, we had a good discussion on our last day. Since our hardware is mostly our own IP we have to learn how it works by poking it and looking at HW team test code, we don't very often get a nice flow chart, sometimes the HW team have to look at RTL to tell us how it works! excellent yes Updating legacy tests to use the cpputest framwork. Show
TDD for Embedded C Very Good Much better Yes I learnt that tests is quite important. It is all about quality, and quality matters the most Good balance Good balance It could be useful to discuss if TDD can be used to test concurrency and time related events. Good For me, having read the book, it was easy to understand the background and the design decision. But I feel like it would have required a longer preliminary discussion about the design, otherwise Very brilliant hopefully :) I think I have to demonstrate myself that I can be more fast and efficient using these ideas. It requires a change of mindset....But it is a started process Show
TDD for Embedded C Very Good Moderately Yes Designing software Driven by test and found errors that maybe I would not have found designing as I am used to. Usage of the CPPutest framework. Good balance Good balance To speak a little bit slow and let the people think about the concpet just lernt. Excellent Maybe more exercises Excellent in giving suggestions Sure. I think It's better start immediatly since I'm still fresh about that. Applying it on an existing project (which may need refactoring) and adapt all the dependecies. Show
TDD for Embedded C Very Good Much better Yes Self-discipline to practice TDD, workflow to follow, tricks to speed up some parts, note about what could be considered not important to test, rational to use TDD Good balance Good balance maybe by adding a list of antipatterns, list of not well-implemented tests to figure out how it can go wrong and why Excellent exercise are greate and well balanced it was a pleasure to listen to him Yes, I can restart tomorrow with more discipline convince others, start introducing against already existing code Show
TDD for Embedded C Very Good Much better Yes I learned a new style of develop that simply task in steps and avoid to spend time in long debug. Good balance Good balance Probably it can be added some hints on rules on how to have a code that can be debugged easily Very Good In case of light control features required are not clear on beginning and it will take a little bit to understand how it can be done. He was very helpful and replies quickly to our questions. I start it today, so I can not lost a day (after travel) :) It will be necessary to understand how code will be sliced and re-written in some case to be testable. Show
TDD for Embedded C Very Good Bring it on! Yes I had about no knowledge on TDD before starting the course. A new world opened to me, made of a brand new programming technique and point of view wrt debug, tests, and coding. TDD is powerful because coding is powerful. Good balance Too much presentation I would reduce the first presentation part. I would reduce the overlapping with the book, giving it a more practical footprint, because the book reading can be done in advance (and shall be suggested to the trainees as a base for properly face the training), while the training shall deal with an additional value wrt the book. Excellent We didn't have much time for exercises. I mean the exercises where fine and mandatory to understand the matter. Also IMHO they represent the value added to the sole book reading. But I would want to complete them for practice, but there was no time instead. maybe cutting off some of the presentation on initial training phase would provise some room for more exercising. This is because starting the exercise took a bit (for me) to understand the matter and start thinking in TDD mode. Very skilled in coding, it is always good to have a senior programmer teaching you golden rules involving the stuff you do every day but that you usually don't have time to learn how to improve. I would like to, but I can't. Because it does not depend on me, but on my superior will to apply those practices. And he depends in turn from people who need to sell the product so I may not have time availability to train my team colleagues and not have time for TDD warm-up, which will take a bit. If it depends on me, I would start applying TDD tomorrow. I may start next week then. As said above. We are often in a hurry to deliver, and we have not much time to start with brand new techniques Show
TDD for Embedded C Excellent Much better Yes Testing early is a good idea. Even testing the 'obvious' is worthwhile and making all tests report a failure at some point is important. Good balance Good balance Very Good The exercises were good. I preferred working with a partner as it meant that many mistakes/typos were spotted almost immediately by the observer. This would have been improved if we could have had duplicated screens on our own laptop to make observation and swapping over easier. James was great! A very easy guy to listen to, who responds to what's happening in the room. Yes Most of my team haven't been on the course, and may find some of my tests in common files a little strange. Show
TDD for Embedded C Excellent Much better Yes 1. Deriving tests from requirement which itself drives writing the code. 2. Patterns 3. UT should run fast, integration test is okay to take longer. Good balance Good balance Everything is good, maybe a bit more of concrete examples in the slides would help deliver the message faster. Very Good More complex exercises to solve. Maybe get snippets of "bad" code and refactor it, test it and build a feature on top of it. Very knowledgeable and experienced. Indeed UT in our code base is very slow. Show
TDD for Embedded C Excellent Much better Yes Good balance Good balance Excellent Show
TDD for Embedded C Very Good Much better Yes a new method to improve production code. Not enough exercises Good balance less talk more practical exercices. Found the course a bit too theorical oriented as it applies mainly to new quite simple code. Good just more exercices very good. A little too much talking... will try... not really applicable to what we already have in the company. Show
TDD for Embedded C Excellent Much better Yes Formalize some past experience and putting names on top of them. Learning about new approaches. Being pragmatic about how to get code under test and which one. Good balance Good balance Very Good Yes and we have identified steps within our development process and our org to tackle Political / Tooling Tooling most likely we can solve Political we need to try Show
TDD for Embedded C Very Good Much better Yes Good balance Good balance Very Good Show
TDD for Embedded C Excellent Much better Yes Good balance Good balance Excellent Show
TDD for Embedded C Excellent Bring it on! Yes I really appreciated learning about the downfalls of Mocks and the Fake Function Framework. Even more, the emphasis on the necessary quick build cycles as part of TDD has pushed me toward setting up my off-target build environment. James is a fantastic teacher, patient, knowledgeable, and humble. Good balance Good balance Better collaborative editing tools would enhance the pair programming experience. cyber-dojo critiques that you may want to pass on: 1. The code area on the page should be resizable or at least match the browser window edges. 2. Collaborative real-time editing from 2+ users (similar to google docs) would be fantastic. 3. Overriding some more common hotkeys like Ctrl+B to build/test and preventing Ctrl+S from showing the "save page" default dialog would be less jarring. 4. Remember the syntax highlighting state per "animal" Excellent Absolutely! Show