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 Much better Yes mocks Good balance Good balance Excellent very good yes Already implemented some the hardware is always changing Show
TDD for Embedded C/C++ Good Moderately Yes How to approach using TDD when you don't exactly know how the hardware operates. And TDD w/ embedded devices in general. Not enough exercises Good balance Consider the target audience, especially for a group mostly from one company. We were generally already sold on TDD and used it prior to this course and were aiming to improve, not be convinced, and I think there was too much trying to convince us. Very Good Show
TDD for Embedded C Very Good Moderately Yes I think the most useful thing is how to use the Mock/fake module to simulate the HW register or memory operation. Not enough exercises Good balance Maybe more various exercises are useful to help us to be familiar with TDD more quickly. Excellent I think how to create a Mock/fake module is very important, but I don't have any idea how to do it. Nothing. I think the instructor did very well to lead us to learn TDD. No. I have to get more familiar with creating Mock and fake modules for the TDD test. Our legacy projects were for the embedded system. We have to fake or Mock the HW for our front end and back end side and lots of register/Sram operations. Show
TDD for Embedded C/C++ Good A little Yes step by step verify the code, when create more test case and found out more defect. It's also change our mind set when doing develop. Good balance Good balance Very Good cut off dependency with HW cost a lot of time. TDD is a great idea, but in fact the project always in rush, implement TDD that mean we need more time to develop and extend schedule. Show
TDD for Embedded C/C++ Excellent Much better Yes Before training I've heard unit test, clean code, refactoring from some blogs, but still don't know how to start it and how it works. This course gives a brief instructions to start with exercise and realize how TDD components mention in lecture material implement in real case. Good balance Good balance Maybe can have a shared markdown note, everyone in the same class can edit, or add some thought about videos or exercise. It can show other's option or some detail point doesn't notice before. I think refactoring can have more context or demo. It's quite useful. Excellent It's a little bit hard to figure it out the test case should like when there is no test case name as hint. Maybe can have more example for ZOMBIES? And I think it can have more exercise for c/c++. With exercises it is easier to understand TDD. Sometimes I have no idea whether I am doing right on exercise or not, maybe can have some implementations for each exercise as reference. (Some videos have discuss the exercise, but not all of them.) Instructor is good! Speaking speed is moderate and clear. In work maybe a little hard, but during some project doing after work can start it right away. It is fun and have confidence to doing TDD. Seeing things grows up as expect makes me feel so great. And if I don't start it right away, I'm afraid I will forget it soon. Though current project size is not so big, but it is already big enough have difficulty to doing TDD. But still can use some concept to Show
TDD for Embedded C/C++ Excellent Moderately Yes The TDD concept which lets me another point of view at development. Good balance Good balance The prep-work can provide more time to do and be familiar. Very Good For first experience to learning, if there are more materials or exercises before the class to guide what the role of mock and fake played would be great. It would speed up my understanding during the live course. Thanks a lot for the TDD concept and step-by-step exercises. It's helpful for me! I think it's hard to directly start from an on-going project. But I will moderately apply TDD concept at my jobs from now on. The effort is too much to cut the dependency of the on-going project which is not developed by TDD. Show
TDD for Embedded C Excellent Much better Yes Uncle Bob's three rule to keep the TDD coding process ZOMBIES rule to start coding the test plan Good balance Good balance Let people know how to choose the topic in the workshop Very Good The light schedule need more guide before doing exercises Humor and love coding!! I will use TDD way to start my design, it let me focus what is important in current stage The code dependency is large indeed and our try-error iteration takes more time! Show
TDD for Embedded C/C++ Excellent Bring it on! Yes Step by step to complete the requirements and make previous progress still working fine. Good balance Good balance No. It is awesome! Excellent No. It is awesome! Thanks for the detail TDD learning course. It make me to think the function design structure again. It is very helpful for me! I think the answer is no. It is hard to cut the dependency from the current working model. We could try TDD programing in the next project! It is hard to cut the dependency from the current working model. Show
TDD for Embedded C++ Very Good Much better Yes It can help me how to build a solid firmware code and also reduce the debugging cycle Good balance Good balance None Very Good None None Show
TDD for Embedded C++ Very Good Much better Yes It can help me how to build a solid firmware code and also reduce the debugging cycle Good balance Good balance None Very Good None None Show
TDD for Embedded C/C++ Excellent Much better Yes Try to dissects a big problem into small parts. Try to think one step by step. This makes our coding structure much more stable. Good balance Good balance It's good to get the concept of TDD. Excellent We were confused about what's the purpose of the exercise. Since we are not aware of thinking from tests, it's not easy to start slowly if there is no other illustration. Yes, it is hard to start unless we try to do it. So I will try to do it from now on. Since embedded firmware are related to hardware module, it's hard to separate them apart and build the test. It also might be a challenge that our source are not independent. Show
TDD for Embedded C/C++ Very Good Much better Yes The concept of TDD. The workshop help us to introduce the TDD starter to our project Good balance Good balance Students is lazy to do prestudy. It would be good if the teacher can talk some about the slides in the video Excellent Very patient thank you Will evaluate which part to start and may need to discuss it with the leader Show
TDD for Embedded C/C++ Very Good Bring it on! Yes Good balance Good balance Excellent Show
TDD for Embedded C++ Fair A little Only if improved The spirit of TDD. Too many exercises Too much discussion none Good none none No. To apply TDD to current project, the effort is too much. I think it is better to start from a whole new project instead of a mature project. Too many infrastructures have to be done and no person can do it. Show
TDD for Embedded C Excellent Bring it on! Yes Good balance Good balance Excellent Show
TDD for Embedded C/C++ Very Good Bring it on! Yes No Comments Good balance Good balance No Comments Very Good No Comments No Comments Yes large codebase, too many header paths to resolve inclusion errors Show
TDD for Embedded C/C++ Excellent Bring it on! Yes Practical ways of doing TDD Good balance Good balance Add new CPP concepts from C++ 14/17/20 Excellent Nice and engaging presentation of the content. Yes, The concepts are clear now. Build time Show
TDD for Embedded C++ Very Good A little Yes How TDD can help to develop a quality code and how effective it is to reduce the production issues Good balance Good balance I think still there is a doubt about applying TDD on legacy code with very huge code base. Can be concentrate more there Very Good They were good Very good presentation no, my legacy code is very very huge, and i don't know how it works my legacy code is very very huge, and i don't know how it works Show
TDD for Embedded C/C++ Good Much better Yes How to create a disciplined workflow which uses TDD to create robust software. Good balance Good balance More focus on integration testing. Very Good If it were possible to do in emacs it would be better. But alas not everyone uses the #1 editor. Very personable, knowledgeable, over all provides good feedback. Yes We mostly focused on unit tests which is difficult to create around software which does not abstract hardware very well. Show
TDD for Embedded C/C++ Excellent Much better Yes Unit Test writing, fakes, spies, mocks and zombies Good balance Good balance Excellent Very informative, great course environment Show
TDD for Embedded C/C++ Very Good Much better Yes Good balance Good balance It would be great to have even more demos (but maybe go slightly less indepth into refactoring excercises). Or show a bit of the nitty gritty refactoring for a few min then skip to the complete result Very Good A little more initial direction could avoid some confusion Great course! Very much enjoyed. I think next time I'd prefer a self-paced learning style (I believe you also had provided this option I just didn't see it). A 3 day crash course is like drinking from a fire hose. Also found the sessions a little long. May be nice to have more breaks, make them short and split up between more days. Or even meet once a week over the course of a few weeks to allow folks to digest the information! I also found it was very helpful to already be working through a TDD textbook prior to the course so I could hit the ground running I would certainly recommend this course to others but I'd want it in less of a crash course format :) Still need a bit more time to practice but I think I'm 75% of the way there Huge legacy code base. Each line of code churn can be very expensive to verify. Show
TDD for Embedded C/C++ Excellent Much better Yes TDD Mindset Good balance Good balance Excellent Show
TDD for Embedded C/C++ Excellent Much better Yes The ZOMBIES method for how to get started writing tests. Once I got started it was easier than I thought! Good balance Good balance Very Good James was very knowledgeable and helpful I need some more time to set up the test harness in my environment Need to figure out how to use a harness in my windows work environment Show
TDD for Embedded C/C++ Excellent Bring it on! Yes ZOMBIES. This really help with creating test list and think of how to approach testing in simple way. Good balance Good balance I don't know. Format looks excellent. Excellent Some exercise's objective is not super clear. For example Exercise 3.1 objective states that we should "Test-drive Flash_Program device from its specification", but actual implementation is done in Exercise 3.2, and 3.1 exercise is more about learning about extern "C" Instructor is very experienced and can answer a lot of various questions about TDD and more! We already started writing unit test in our company ~4 months ago, but TDD was not widely adopted. Now I will start to practice TDD more where it makes sense. Legacy code, but we will start phasing it out, and do major rewrite of our code base (mostly because of chip shortages we want our code to be more portable). In new gen project I do not se any blocks which would prevent applying TDD. Show
TDD for Embedded C Excellent Bring it on! Yes That writing tests can be fun Good balance Good balance Discussions after exercises are bit to long or more short breaks should be included, since it is easy to loose focus when listening for straight 2 hours. Excellent I think exercises were perfect Instructor seemed very experienced and he knew what he was doing. I liked the way how instructor presented various topics: background pictures, flowcharts, real life examples I will try my best to apply TDD knowledge fear, that at the beginning it will take a lot of time to deliver something Show
TDD for Embedded C Excellent Much better Yes the TDD work methodology. Good balance Good balance 4 days. the last subject (fake framework ) was very short. one more practice on it, would be nice. Excellent all is perfect. amazing. a lot of experience. a real master. yes. I have the opportunity to do it from now. in my initial state, is the time needed to master the methodology. Show
TDD for Embedded C Very Good Much better Yes Going through the flash write demo really drove home the utility of writing tests as you go. I have spent an unreasonable amount of time debugging code with similar functionality. TDD would put a stop to those problems. Good balance Good balance I think you should give out copies of your book as a part of the course even if you increase the price of the class by that amount. Good I would have liked more info on the basics of cpputest earlier in the course and less on the more advanced features at the end. I struggled with the flow in the beginning because I didn't understand how cpputest worked. Maybe 10 minutes of class time, not a video. I enjoyed the occasional '80 reference, although I suspect I was the only one who recognized them. I haven't heard "I love it when a plan comes together" in decades. I don't think so. I feel like I need a day or two to setup cpputest correctly with my current workflow. As far as the TDD concepts, yes, I can. Our firmware is stable and I occasionally have breaks of a few weeks from it. It is tough to implement it if I am not using it daily. Show
TDD for Embedded C/C++ Excellent Much better Yes The iterative process of executing TDD. Not enough exercises Good balance I enjoy getting my feet wet rather than demos, so for me, I'd enjoy more exercises (maybe 2 smaller ones rather than one bigger one?). Excellent n/a Very helpful, his answers and explanations were clear. Well, not tomorrow, because of the nature of what I'm working on right now. But probably next week! Mostly setting up the tools, and learning how to use them effectivley. Show
TDD for Embedded C Excellent Bring it on! Yes TDD is practical; it was easier than I thought. Not only did it teach us TDD, but it provided insight into the design of the software. Good balance Good balance I wish I had more time with the course material prior to the course. I understand that you wouldn't want to compromise your material in the event there's a cancellation, but going through all of the homework, optional, and pre-work for each class was longer than I expected. Very Good I thought the course was very straightforward and insightful into our development practices and how it would shape them moving forward. Yes. The combination of the tools used, the training documents, and the course gave me confidence to implement cpputest into my projects. Previous experience integrating TDD into our workflow (currently determining the needs for validation of the Cpputest), timelines and accessibility are areas of focus in our development group, and software is very new to the company. Our manager has been supportive and as long as we provide a business case for these concepts, then we can pursue support from our IS team or a consultant. Show
TDD for Embedded C Excellent Much better Yes Getting to see a practiacal demonstration of the short cycles of TDD. It was enlightening to see just how small the changes should be each time. Good balance Good balance We had a brief follow-up session on getting legacy code under test. It would be great if this could be incorporated into the course with some practical exercises. Excellent Friendly and confident. Easy to understand. Very helpful. Mostly, yes. However, to be truely effective, we need to get our legacy code under test. We would also benefit from a better unit testing tool. CppUTest looks like a very good candidate, so we will look to migrate to that. A large amount of legacy code. Not everybody has had the training yet. Some have made it quite clear that they are not interested in writing tests (altough that opinion might be changed by taking the course). Show
TDD for Embedded C/C++ Excellent Bring it on! Yes I was very impressed with the mock framework for simulating hardware interfaces. This will be very useful for me in the future. Good balance Good balance Providing a complete version of the exercises for review after the class would be helpful. Excellent Perhaps the LightSpy exercise could have clearer instruction. I struggled understanding the direction of the homework exercise before the class explaination. Obviously very experienced in TDD and excited about the material. I am already using TDD in my work the day after the class. Show
TDD for Embedded C/C++ Excellent Much better Yes Re-highlighting the need to move in small steps. I really liked the mock-ing portion of the flash device driver. Good balance Good balance I'd prefer an in-person learning. The course was very good though. Excellent Providing the exercises in advance might be helpful. Very friendly and likeable. Seemed very qualified for the part. Yes, I think I could apply the learned TDD techniques to my work immediately. Fighting the existing infrastructure already in-place. Show
TDD for Embedded C/C++ Excellent Bring it on! Yes - Practice the TDD cycle in hands-on exercises - How to not overuse mocks. - Different testing strategies - Refactoring strategies - How to test legacy code Good balance Good balance - Present the goal, rules, round table, etc at the beginning? - The presentations were hard to follow. They didn't feel well structured. It would help a lot to have chapters: here's what were goin to do and why, theory, example, example, recap of the learnings, then on to next chapter. - The live demonstrations were too long. I would forget what/why were were doing before the end... - I know it's hard when online, but maybe encourage more participation from the participants? Excellent - The online compiler doesn't allow debug. It makes it hard to figure out why our code isn't working sometimes. - The revert function of the online compiler didn't seem to work. Thank you so much for sharing this knowledge with the world! I actually am! Just as the class finished, I was tasked with unit testing changes to legacy code. Within 1h, I had the environment setup and running an empty test. Take the time to change our way of working: setup tools, get familiar with them, etc. Show
TDD for Embedded C Excellent Bring it on! Yes Honestly there were tons of useful information/concepts about the training. Pair programming TDD and seeing the practical aspects of the TDD cycle. A very inciteful course in how to develop software properly specifically for embedded development. Good balance Good balance I don't have any. Excellent Maybe a little more understanding of the key components/modules and their relationships prior to doing the exercises but that was what the homework was for. A very good presenter of the topic. It is apparent that James has decades of invaluable experience and knows how to present the material is light hearted and structured way. That's the goal to start TDD today in our code base. Communicating the complexities and the time needed to inject the TDD process in our development. "Slow down to go fast" Show
TDD for Embedded C++ Excellent Much better Yes How to apply test driven development Good balance Good balance Sometimes the instructions were in the website and sometimes the instructions were in a file in the code dojo which was confusing where to go when starting a project. Maybe more consistency there Excellent The exercises seemed to do their jobs well. Yes when I get another embedded project to work on The legacy code we have Show
TDD for Embedded C++ Very Good Moderately Yes The purpose of the tight loops, i.e. to ensure the tests will FAIL when they're supposed to. Not enough exercises Good balance I think a little more time spent doing exercises would be beneficial, as that's how most of us learn. Excellent Taking the first step on some of the exercises was often the hardest part, and we spent a fair amount of time "stuck" on that. Anything that would've helped us get moving on our own would be useful. I think the chosen exercises, though, were excellent. I'm sure there's been much thought put into creating exercises that are familiar, but also provide teaching value as well as an opportunity for a-ha moments. I clicked very well with James, as it's evident he and I think alike. We started a few years ago, at least some of us. For me, this was an opportunity to fill in some blanks about WHY, and James certainly did that. But most of my organization has not been exposed to TDD, and I think it was a good start. Unfortunately, I got pretty limited feedback from other colleagues in the class, but the little I did get indicated there wasn't quite enough time to cover the material. Without a doubt, getting everyone on board. Show
TDD for Embedded C Very Good Much better Yes I learned a lot. Here are 3 important points: - Hardware / target is the bottle neck; Debugging / troubleshooting on the target in a large monolithic software block takes much longer than in a TDD environment - I got to know a new TDD environment, before that I was familiar with cmocka / valgrind - I have seen that the software complexity has to be kept as small as possible in a TDD environment Not enough exercises Good balance For me as a non-native speaker, the fast language in the videos was a problem. Good More time for the exercises. Especially on day 2, the workload was not even rudimentary. - From a technical point of view, you could start right away. However, our internal project organization does not allow this. That would cost a lot of time and money at first. Note: In my career there have been projects in which a large part of TDD development has been done, e.g. DSP software for the NodeB. The reason: With 100 percent code optimization on the target, debugging was not possible. We had to simulate everything beforehand. My experiences with it are technically absolutely positive. However, an appropriate organization in the project is essential. However, an appropriate organization in the project is essential. Show
TDD for Embedded C Very Good Much better Yes "Procastination" "Add test for each single line of code - before writing it" (I don't think it is practicable though) "Analysis Paralysis"! Too many exercises Too much discussion James has exceptional teaching skills and is perfect in handling slides and videos. I would recommend to put a bigger emphasize of this. I would prefer to have less "hands on" (I know other colleagues see this differently). Very Good It is not necessary after seeing the introductional video and seeing James' presentation to repeat each single step once again. I would have expected we can start from where James had put us and really learning by doing new things. See above! I could - if it would fit to my daily work and schedule and I see the need for. Show
TDD for Embedded C Very Good Much better Yes My significant learning is not about TDD itself but about humans. Obviously keeping one's habits is quite common. But to my surprise even some of my really experienced colleges did not even get the point of TDD. "Too much TDD for us" was one of their comments. I ask them whether they what to do some kind of 50% TDD instead and what the hell this should be. In the end it means they will do no TDD at all. So my job for the near future will be to convince them that we need more tests and that this will never happen without TDD. And that TDD is possible even for our code basis. Fortunately I have a meeting platform where I can show examples on a regular base. Good balance Good balance Send information about day 4 more early. This went bloody wrong. Nevertheless we managed day 4 in a sufficient manner. Excellent No idea. I really liked them. Skilled. No. But just because I will be busy with non-programming stuff. Convince the team that we need automated tests. Show
TDD for Embedded C Good Moderately Yes TDD Mindset, creating a test case first.... Good balance Good balance complete Training Material to download at one step Good choose exercises fitting to companies background good agile presentation yes TDD isn't suitable for testing binary libraries and tool generated sources; we have a lot in "low layer" modem. Show
TDD for Embedded C/C++ Excellent Much better Yes Well, most of the concepts I've learned I did already by instinct the one or other way. What I learned is how to do it right. Good balance Good balance Hm, the only thing I can think of which I feeled a bit tiring was the demonstration at the end of the last day how to get some sources buildable. Actually this is my daily work and I think this of my colleagues as well. Maybe it would be a good idea to ask after 10 minutes demonstration if everybody got the point already before continuing for 30 or 40 minutes. Excellent For me they are good as they are. Very skilful, patient, accomodating, adaptable to the specific problems of the trainees. And a very good understandable English which is very important for non English mother tongues. Yes, as I've already written I used most of the learned concepts already by instinct at least somehow. Now I know how to do it right and consistently. Unfortunately I've almost never the luck to write a software on my own from scratch. Instead I usually have to adapt mostly very complex 3rd party sources to our requirements. I've learned how to use TDD there as well. Constant refactoring is an important concept of TDD and actually it almost always itches me to do so also with used 3rd party sw. Problem with this is that it makes often required merges of new deliveries much more difficult up to impossible. So refactoring is not always a good idea. But this of course doesn't prevents me of at least adding testcases for the things I have to change or add. Show
TDD for Embedded C/C++ Very Good Much better Yes Importance of real unit tests to keep software maintainable Good balance Good balance Very Good Some excercises where challenging, but thats also important to keep them interesting :) I need to get some more experience to apply the learned techniques intentionally rather than focus on actually doing TDD Show
TDD for Embedded C/C++ Good Moderately Yes SOLID principals Not enough exercises Good balance Class participation was very low. I think this was partially because it was virtual training, and partially because several in the course were new hires. I was signed up for this training and had no knowledge about what it was prior to the first class. This made it difficult to say what we were hoping to get out of the course, and also likely contributed to the low participation. Very Good Some more in-depth exercises around apply UTs to legacy code, and design patterns would have been helpful to solidify the concepts. I liked James, he had good stories about his experience. I could tell he was frustrated by the low level of participation. Also, I think more time was needed in order to go through all of the material, and we could have used more exercises. The environment is not test-driven, and there is not much emphasis on UTs (that I can tell so far being a new hire) Show
TDD for Embedded C Very Good Much better Yes testing strategies in embedded Too many exercises Too much discussion - more focus on concepts, testing theory, technical aspects and challenges Very Good not applicable nice preparation with commercial taste yes separate the hw dependent code as much as possible Show
TDD for Embedded C Very Good Much better Yes Learned, why TDD is beneficial and how it can be used to test Hardware, before Hardware becomes available. And how I should use TDD in practice. Good balance Too much discussion It would be useful to have short breaks during the workshop. It would also be great to have a bit more time on the technical exercises and maybe to spend less time on the end of first day discussion about likes and dislikes. Have the homeworks and what will be done in the workshop available a bit earlier, having the time difference and being at work before the workshop made it difficult to find time to prepare. Create a pdf only of the charts for implementation, switching between screens for sharing and looking at the town made it difficult to remember what had to be implemented. So a pdf, of the flow-chart, which could be printed out before the class could be useful. Good The excercises in the first day were very easy. The second day excercises were alrigth. The third day the preparation videos got me confused, why the tests contained the read and write functions and in the implementation they were written in the flash file. For the rest, once I got the concept it was easy to implement the rest. Excellent presenter, funny and enjoyable to follow. Not at work, but yes. Currently I am not working on C or C++ projects. Show
TDD for Embedded C/C++ Excellent Much better Yes I was partially aware of TDD before the course. The examples and seeing you doing TDD gave a good feeling on how it is done in practice. The small steps were even smaller than I expected, happy to have experienced that. The thing that "flashed" me was seeing you refactoring the LightController with "keep the system running" in mind. I've never seen (the art of) refactoring that way. So I learned that I have to learn and practice refactoring. Good balance Good balance The first two days there was almost no break. Well, you said "when you need a break during the exercise, do it", but that did not work good for me. I wanted to practice and kept going on. I would have preferred multiple short (scheduled) breaks, ~5 minutes here and there, to get a coffee and relax the thing between the ears ;) Excellent Exercises for me went very well for me. It seems to be very dependent on the partner. I had good luck on two days, exercising was fun und enlightning. Good personality, both feet on the ground. I appreciated your "normalness". I saw you as a very experienced expert, willing to share your knowledge (and not god talking to people - even if you are (TDD) god :). Since a few months my customer started with unit-testing. The team will for sure try to implement the new TDD approach. In our company it may take some more time. I'll prepare a summary talk about my experience in your training and hope to inspire at least one teammate. I'll immediately start with TDD in private. I have a pending project (lamp in kids dorm) that is similar to your LightController example. The lamp works most of the time, but not always and would need some debugging (that's why the project is pending, I fear to touch it). Now I decided to re-do the implementation, strictly following TDD. The key challenge will be to convince upper management that spending more time for the implementation phase will pay out later in the project. Show
TDD for Embedded C Very Good Much better Yes That i write bugs, ehm sorry, tests :-) Iterate you code with smalls steps and therefore set a focus. Not enough exercises Too much presentation Maybe do more and shorter excercises. Split the excercises in smaller portions and discuss them shortly. Then go on with the next part of the excercise. The last part of each day was a bit hard to listen to you and watch you do coding for such a long time. Alternating: Theory and examples. Very Good More focus on the TDD methodology and a bit less code engineering. We spent a lot of time during the excercises finding the right solution. Dont get me wrong, for a C developer the excercises were not difficult! Maybe think of providing more prepared samples or guidances. Maybe it was also a problem of not being aware of all your hints... We as a team think we would be ready. We have to challenge our toolchain (build times) and our SW process. But we think we could start soon. We have to provide unit test anyway (medical). Show
TDD for Embedded C Very Good Moderately Yes The TDD principles. Fail, Pass, and refactoring. Good balance Good balance The embedded part of the course was a bit vague. Important topics such as, for instance, interruptions and tests on the hardware should be discussed. Very Good The test list was always given. It would be interesting to make an exercise from scratch. The instructor was very pragmatic and well prepared. Well, I could start tomorrow to apply the principles, but with certain limitations ( long build time, legacy code and so on). The extra time needed (especially at the beginning when I do not have a lot of experience) and building time. Show
TDD for Embedded C Excellent Bring it on! Yes TDD guided by zombies; gather town tool Good balance Good balance I was prepared to spend full days in this, as if at a physical. But I lost motivation after "class dismissed", although in one instance my pair buddy and I agreed to pair in after class for a bit. Would have liked to mingle with other attendees after hours. In physical space we might have a mixer, dine together. What might be equivalent? Organizer arrange nachos & chips sent to homes of participants? Something after formal lectures, mixer, or encourage pair study "OK to hang around with your pair buddy, go deeper into exercise, I'll pop by in a couple hours" might helped me put in the full days I'd planned. Excellent don't retire yes. We're not green field but rust programmers applying strangler pattern to a body of legacy C++. Skills gap challenge. Show
TDD for Embedded C Very Good Much better Yes To first write failing tests of my code then enough code to pass and then refactor. Repeat cycle until done: faster than fixing hidden bugs that sneak during traditional coding. Good balance Good balance Maybe do the hands-on together with the whole group, to keep everyone at same level, and clarify any discrepancies between each team implementations. Excellent Provide additional explanation of error screens for clues on how to pinpoint sources of error. Very articulate and knowledgeable, with a great sense of humor. Forced into other higher priorities. Legacy code to maintain, limited resources, schedule pressures, responsibilities not falling directly on me. Show
TDD for Embedded C/C++ Very Good Much better Yes Mob programming, writing tests first, how to make them pass and refactoring the code by making sure that we are not breaking anything else. My favorite part was doing exercise. Good balance Good balance Little bit more hands on activities. This suggestion is for people like me as my attention span is not that great during the presentation. I pay great attention during hands on activities like mob programming. Excellent Like someone mentioned we need to take some breaks. People is west coast started at 7 in the morning where they didn't have anything as needs to take care of the kids or something else. Show
TDD for Embedded C Good Much better Yes - Schedule pressure initially increases the feature velocity, but then has the opposite effect through poor code quality and increased defects (slow down to go fast) - Bad code should be improved incrementally (one verifiable step per increment, it is easier to keep a system working than to fix it after you break it) - Unit Tests: Just using C with classes of C++ Good balance Good balance - I didn't quite understand the purpose of this live coding in the second part of the session. I saw the point in the first part to prepare us for the exercises but watching you have compilation errors and linker erros again and again in the second part I didn't understand. - I missed a schedule for the day Very Good In my opinion, the exercises were very well prepared and I do not know what can be improved. Good explanations, but sometimes digressed too far from the topic. Yes because there is no impact on our SW process - Making colleagues aware of the benefits of TDD - The current toolchain is quite slow. Fast feedback is needed to apply TDD efficiently Show
TDD for Embedded C Excellent Bring it on! Yes How design fits into the TDD process Good balance Too much discussion I would have removed the Legacy Code section. This is a separate course in itself. Then we could have had one more hour on another TDD specific topic for which there are plenty in your videos Very Good Split them into 30 minutes slots with a discussion in the Tiki Bar Level of knowledge is exceptional on the topic For European audiences you take to long to get to the point. For example when addressing the parking lot items sometimes we lost the plot. Good to bring in your considerable experience to explain an issue with an past concrete example but keep to the point and ensure the question has been answered. Monday for sure :-) We have some limitations with our dev environment which we need to work on. We are a medical device company so we must comply with strict methods of developing and testing SW. We will need to adapt our processes to allow the use of TDD as prescribed in your course. But we are prepared to do this to get the advantages Show
TDD for Embedded C/C++ Good Much better Yes I learned how powerful it is to implement and refactor software in small steps while having a good base of unit tests as a safety net. Good balance Good balance At least for me, the excurses to C++ were a bit too long. But i just realized the curse was C/C++ ;) Very Good For me everything was clear, but I already had experience with CppUTest and CppUMock. So I was able to focus on the important thing. For my colleague in one training, it was a bit hard to get started. Not sure how to improve, maybe you could instead of presenting the first 1-3 steps of exercise do it in the group together. Then it's a bit slower and the opportunity to ask questions is a bit better. Not in the current company project, but I will certainly use it right away in my private projects. The environment in my current project does not allow such an approach. Show
TDD for Embedded C Very Good Bring it on! Yes To restrain myself to only take small incremental steps. Good balance Good balance On the second day, the excercises were a bit much. We didn't make much progress and it would have been better if we could have gone through more of the exercise the day of in order to appreciate more the benefit of dependency injection. Good Maybe clearer hints? David has done a smashing job. He managed to convey the concepts in a clear and non boring fashion. Not right away, we just need to add/choose the test framework. We have a lot of legacy code. Show
TDD for Embedded C Excellent Much better Yes The mock is the most useful thing that i think allowing me to emulate the hardware interface without the hardware Good balance Good balance I think it is the best that it can turn out to be. Well done. Very Good If I can recommend, I would recommend to spend less time on circular buffer. I even would recommend to substitute the light scheduler with some more hardware emulation or interrupt emulation. I think you covered the topic very well. I liked the idea that requiring us to watch video for the concepts will be recovering. That helped to reinforce the concept again during the presentation. We already started on some projects, so it will continue. In regarding to the existing projects, i think it is a balance approach. I remembered one powerful statement during the training was that to find a way to implement TDD. Depending on the level of ease, some can be hard. This leads me to think differently on how to use TDD on existing projects without doing a lot of code surgery. The existing codes are too big and were not started that way. Show
TDD for Embedded C Excellent Much better Yes Programming in small steps. Then test. Good balance Good balance Excellent I will repeat the exercises again to understand everything. Then I still have to adapt the knowledge to the programming environment in which I program. The challenges are converting to a different development environment and convincing my colleagues how useful TDD is. Show
TDD for Embedded C Excellent Bring it on! Yes The test doubles module. Just being able to create a test double from a precompiled library and have the linker "sew in" the test double was pretty amazing. Good balance Good balance Might be interesting to make note of integration tests (a segue to another course perhaps?) It would be interesting to apply SOLID principles to embedded C design. Excellent I don't think they can, really. They are applicable to embedded C and are just the right size to fit into the training timeframe. Most importantly the exercises emphasize the focus on the TDD pattern. David Cozens taught the course very well. I had a lot of questions and he was able to answer them on the spot or from the parking lot at a later time. I can technically start tomorrow, but we are in the requirements phase for the project, so a little premature for testing just yet. Truth be told, I've been doing TDD for years and I still learned valuable techniques as did my new colleague. Our organization is very welcoming to TDD. I think the heritage of our business is to acquire products (and therefore code-bases) which do not have tests. I would find value in learning to test with legacy code bases. The other challenge may be in, as David put it, helping other developers convince themselves whether TDD is worthwhile or not through subsequent training which I will provide to our team. I have no idea why someone would not do TDD after they have been through this training. Show
TDD for Embedded C/C++ Very Good Much better Yes That we can apply TDD it to legacy code. Good balance Good balance I wish you spend more time talking on how to create/write the test list. I found it difficult to come up with a good tests. Good Good job on answering the questions and explaining. Little bit in hurry sometimes but maybe because time limits. I hope soon. To convince others that TDD is worth the time invested in learning and applying. Show
TDD for Embedded C Very Good Moderately Yes How TDD works Good balance Good balance Design the exercises so that they can be followed more easily Good Make instructions more clear Very helpful and described the concepts very clear Don't think so. It would be an organizational effort. Overhead time with tight project deadline Show
TDD for Embedded C Very Good Much better Yes writing one Test and let it fails and the fix it first, results in less written code/tests than writing a batch of tests and then fix each test. Good balance Good balance i was familar witch test-frameworks. But for one who does not have seen such frameworks it could be difficult to follow. Maybe for such attendees you should frist show the videos of the homework first and then let doing the exercise. Excellent exercises are good. But Mocking in CppUTest feels like pain ;) Maybe a Testframework for C for the Embedded TDD C-Course is better. Give Ceedling with Unity chance. It includes also the Fake Function Framework (i have not used it yet) and i find that mocking is a littel bit more better to implement. because i used it (a bit differently), i have to change only small things to start tdd in its correct way. legacy code has not often a terrible complex interface. If the interface has to much arguments for the functions they are "untestable". Show
TDD for Embedded C Excellent Bring it on! Yes Small programming errors are found quickly because of the short test cycle. Good balance Good balance The course is fine as it is. Very Good The exercises were close enough to real life situations to make me appreciate the value of TDD. You did a good job David! Very helpful. Yes, I can and I will :) Get everyone aboard. Show
TDD for Embedded C Excellent Bring it on! Yes Securing the future development and be confident of changes while moving forward. Good balance Good balance May be mixture of presentation and exercise. instead first presentation and then exercise. Excellent Good enough. Everything is well organized nothing to say. Yes. Because I got the core concept. I am not so good in environment setup. That may be a bit challenge. Show
TDD for Embedded C Excellent Much better Yes It is better and faster to write test code before writing production code. In the long run it will keep the code more maintainable and cleaner and best of all hopefully bug free. Good balance Good balance The course did a great job introducing TDD. Implementing the principles into the legacy code will take some time to get used to, to make the process of finding the right tests especially in small steps effective Very Good They were a good starting point for TDD David did a great job explaining how to apply TDD. He also gave a lot of recommendations on how to improve the code further. Thank you and James for taking the time! I will definetly start implementing TDD from now on and improve my skills using the techniques learned general opinion from some colleagus is that automated testings of code take to much time. Improving the software product without generating bugs in the long run will hopefully change their mindset and improve the overall quality of atleast my code. Show
TDD for Embedded C Excellent Bring it on! Yes I already have extensive experience in TDD, and this course still helped me refine and reflect on some of the things I do to gain better understanding. More specifically for C, how to do "interfaces"-like decoupling for C at linking level instead of actual interfaces, as is done in higher level languages. Also, how to leverage TDD to help with the hair-pulling problem of linker errors which you don't know how you caused exactly. Good balance Too much presentation Overall, I think you did a great job, especially with the excercices, which lead to unexpected autonomous conclusions. Since I was an educator myself (and perhaps will be again), I am obligated to point out that concepts like flip the classroom are incredibly important. It may be good to see if you can introduce more interactivity with playful ways of getting people to interact with the problems they have. Can you e.g. without requiring code use a 'game' of some sort to switch up the story that would otherwise be a long presentation? It may be worthwhile to see if to a small degree you can grab on to real-world examples in the same way as in Burkhard Stubert's workshop and bring that into a context to test with. It's very tricky to do this though, but very worthwhile if it can help break up what would otherwise be long lectures. (Anyone who's ever done comp-sci expects lectures though.. and this expectation also applies to courses such as these I guess, so it may not be good! ) Excellent I think the excercises already balance cognitive load and complexity very well. Still, it is vital to keep complexity to a very low level. Unfortunately us developers expect 'challenges' that intellectually challenge us.. this is in conflict with the requirement of introducing new concepts; people may be overburdened. By choosing the most relevant 'complex' examples that are widely understood by almost every participant, this should be achievable. The circularbuffer example does a pretty good job at this. It is worth exploring if 'simpler in terms of cognitive load' examples exist which can help increase the amount of focus participants can expend on applying TDD properly. Small improvements in the "behind the curtains" checks to make sure people employ TDD properly are possible. It would also be good to have clear instructions on how to use the cyber-dojo, to maximize the performance people have and minimize confusion. You look older in real life than in the profile pictures I saw :D.. But that is a good thing; getting older is far preferable to the only other alternative. You make good usage of your hands when explaining things, you use clear language and have a good cadence and speed. There were sometimes occasions where you were in a long story and I noticed that some of my colleagues were drifting off; this can be avoided by adding in tiny snippets of interaction, even if it's just a question. (The question should be very simple though, trivial even) the act of placing people on the spot even for a relatively simple thing, having them think along just slightly, can help keep them on board with a story where otherwise attention may falter. Virtually every educator I have worked with, including myself, sometimes simply just talks for too long and we should always think of how to keep people on board :) - Your didactic skills are good, but can be improved even further. No, tomorrow is a Saturday. Also, we already started in other places and made a start in the workshop already, which is comitted to GIT already. I will ask with the author of the branch to see when/if we should merge it to master and how to make sure that we get CI set up :) We'll need to keep on our toes and make a practical balance between the ideals of TDD and the practicality and pragmatism of developing with legacy code. While James correctly states that we should probably start scratching our head if we always make excuses for not making a test immediately.. it does raise the question: should we have rules? Do we need them? What if we end up being too lazy? Maybe we just need to give someone a TDD cap and ask them to keep an eye on things and reprimand those who sin against uncle Bob's laws? Also, as any developers knows, we tend to start to get cocky and try to take too big/too many steps at a time. We're going to end up writing tests that skip steps and end up tripping. Show
TDD for Embedded C Excellent Bring it on! Yes test Good balance Good balance test Excellent test test test test Show
TDD for Embedded C/C++ Excellent Moderately Yes You can see a better path for progress. You have defined milestones and it's easy to go back. TDD would help me to have more structure and identify more clearly and faster flaws on my code and logic. It still seems like more work and it could be, but I think it will be less noticeable the more I get used to it since I would be improving in other areas. Good balance Good balance I was happy in general and it is good to have the legacy code workshop after. Also, I enjoy that the videos were not really long, it's easier to watch them and prepare for the next day. Very Good The exercises were good and I am happy with the content. I think my only concern was time since TDD was a new concept to me, it took me a long time to advance with the exercises. The course instructor offered clear concepts with personal experience that allowed a better grasp of TDD. The instructor for the legacy code workshop was very good offering guidance with the set-up and how to approach the tests. Both instructors were very encouraging and easy to approach to discuss about TDD. It would be a gradual introduction of TDD to my routine. It will take me some time to adapt to it. I would think that time. I feel with legacy code may be more difficult, writing the tests and setting them up correctly take some time. But with new projects, it could be implemented from the beginning. Show
TDD for Embedded C Very Good Much better Yes As this was my first experience to TDD, the most useful thing for me was being introduced to the mindset of how to work efficiently with TDD. Good balance Good balance Just a minor complaint. The cyberdojo is somewhat annoying to use, when you're used to autocompletion and such. However, it might serve it's purpose be slowing the developer down and not develop by old habits. Excellent Show
TDD for Embedded C++ Good Moderately Yes Too many exercises Too much discussion Fair Show
TDD for Embedded C/C++ Excellent Bring it on! Yes Exploding fakes, work in small increments, be patient with the development. Good balance Good balance Provide more case studies. This will help the attendees correlate with their problems. Very Good Maybe the exercises could be spread out a bit more to allow sink in the concepts while they are presented. Nice job! :) Yes! Because I had read your book before and was already interested in TDD. I went to the course with excitement and it did not disappointed. I hope to be able to overcome the challenge that comes with the eagerness of going fast and ignore the small steps. None. The company totally embrace new methodologies that can translate into better value for the money :) Show
TDD for Embedded C/C++ Very Good Much better Yes I had never worked with TDD before, and had heard very little about it before the course. My impression before the course was that TDD was only used to prevent bugs, but I found quickly out that there is more to it than that, such as refactoring and writing a better structured code when writing new code. I really liked having a step by step method while writing more secure code. Good balance Good balance Very Good I had not heard about mock, spy and fakes before, so personally I had a hard time to fully understand their use case and how to set them up. These were already set up, maybe it could be an idea to include setting up the mock/fake/spy as a part of the exercise? Not fully, due to the "How can the exercises be improved" part, i.e. I'm not so confident on how to use mock/spy/fakes. Show
TDD for Embedded C Good Much better Yes Good balance Good balance Very Good Show
TDD for Embedded C Excellent Much better Yes A lot of (obvious) things I knew up front, like the need for abstractions, that global variables are bad and that dependencies needs to be kept under control and at a minimum. The TDD course shows why this is not just academic best practices but needed practices to get clean and testable code. Good balance Good balance Maybe a bit more of a debrief after the workshop. We end up with a lot of faked stuff and a couple of very basic tests. It's early days for us yet, but no clear path yet how this should evolve into better interfaces and cleaner code (eventually). I guess it's a lot of hard work before we get there, but as I see it getting these tests is not a goal in it self, just a means to enable refactoring. Showing and clarifying that path could be good. Excellent All good Thumbs up! Yes, but I think maybe we should re-evaluate the choice of toolchain. I think Google test could be a good choice even in an embedded system in C if you start from scratch, but the workshop showed a few difficult parts in the C vs C++ category that we could avoid with a pure C framework. And I would think we could get quicker compilation, which would be a big deal with TDD... The problem is that there is really no obvious choice for pure C framework... Getting people to take the time. Getting project managers to approve of people taking the time. Getting some ground rules and the framework settled (always takes more time than expected). Show
TDD for Embedded C Very Good Much better Yes A new way of programming and testing. Programming in small groups might be more effective since exchange of ideas might lead to a better product. Good balance Too much presentation More exercises. Very Good Simple more of them. Explanation of what each file is supposed to do (ringbuffer exercise) Very experienced and competent instructor. I would not able to start tomorrow. Still some things needs be solved inside the company on how and where the new information needs to be implemented. Old entangled code which should be changed during the process of using TDD. Many hardware dependencies which needs to be sorted out. Show
TDD for Embedded C/C++ Very Good Much better Yes Good balance Good balance Very Good Show
TDD for Embedded C Good Much better Yes Small step Good balance Good balance Use more specific examples from the customers code base throughout the presentations, instead of circular buffer and light schedular. Fair time Show
TDD for Embedded C Excellent Much better Yes Process for achieving full test coverage while also reducing workload Good balance Good balance By having more of it. Excellent The last exercise with the flash-programming had several steps that were plain repetition of the previous steps. You add a test for checking an error-bit in the status-reply. Then you do the same thing, but with a different error-bit. Then you do the exact same thing again, but with yet another error-bit. I think it would have been enough with a single error-bit check. Or perhaps some variation on the specified behavior of the flash-programming-module when it detects the different types of errors. Thumbs up No. Because its weekend and I intend to drink beer and watch the football instead of working. Some are already able to deliver "perfect" code. If your code is "flawless", then of course you dont need to spend a lot of time on testing it. There are no know bugs, so you dont need to spend a lot of time on debugging it. You see the firefighters? cant be related to your code since that code is "flawless". ignore them and focus on your next task instead. So if you are already spending most of your time on writing code and almost none of their time on doing tests and debugging. Then TDD would just seem like additional workload. Show
TDD for Embedded C Excellent Moderately Yes Considerations around different kind of tests doubles. Which ones are available, and how to select an appropriate one. Good balance Good balance The course is already very good. The only thing I could think of would be if some of the best parts of each teams exercises could be quickly highlighted at the end of the session, I am thinking that this could help boost confidence. I also feel that other testing techniques were not even mentioned. For instance fuzzing, Domain testing might be more appropriate for some embedded application like motor control. It would be good to include some information about other tools, and when they would be appliccable. Very Good When "getting ahead of oneselves" in the exercise it was not always clear what the "problem" was. Comes across very as knowlegable and hands on. The material is presented in a with an eye on practical application. Presentation is clear, and the answers to questions are always instructional, even if the question is off topic :-) I will choose the right tasks to try it out. For instance I have 2 tasks on my back burner : Implement HW independent I2C driver for a sensor , and hook up some GPIO pinst to interrupt actions on a microcontroller. The former will be very well suited to TDD, but the latter not so much. I expect that to just work once I have done the correct device configuration. It will be fairly obvious if there is a defect, and time will better be spent on reporting a diagnostic error message if it should fail. We have much legacy code, and limited green field projects where we can gain the most experience from exercising TDD. Show
TDD for Embedded C Excellent Bring it on! Yes test Good balance Good balance Excellent Show
TDD for Embedded C Very Good Much better Yes How TDD can be used to aid development Good balance Good balance Escpecially for our group: More focus on how to use legacy code fr TDD Good In principle yes but currently we are in an approval process which has o be finished first. Use CPPUTest framework for my existing code. Show
TDD for C Very Good Much better Yes - Good balance Good balance - Very Good - - - - Show
TDD for Embedded C Very Good Moderately Yes integrate TDD into existing projects Good balance Good balance better matching time zone :-) Very Good really good exercises, showing the concepts very good. I can. Do I will ? hardware related, proprietary interfaces. Most of my code are already adaptions, like JNI. Show
TDD for Embedded C Excellent Much better Yes The strategy to check code functionality with TDD in common and also not to be afraid for using TDD with "old" legacy code. Good balance Good balance From my point of view a bit more time for discussions, even if the balance between presentation and discussions was good. Excellent A bit more time for the exercises We can and our leader wants that we start as soon as possible! Me too! The decision which existing components will be the first/next TDD usage candidates. For sure, new components will be created with TDD from start. Show
TDD for Embedded C Very Good Moderately Yes starting to develop new code should be done under supervisory of tdd. Legacy code to rework need huge amount of time and should be use carefully to not violate delivery schedules. Good balance Good balance The exercises should be cleared up. As a pupil it was not everytime clear what is to do and how far the exercise should be done. Very Good Tool is nice. But as developer I had often the intention to search through the code to finde declaration of function name what is not possibe or at least not known by me how. Good understandable also for not native english speaker. Thumb up. I'll try. I need to get used to and be sure about the setup. The preparation phase forlegacy code. The thinking construct to avoid to do more than one step with one jump. Show
TDD for Embedded C Very Good Moderately Yes - The iterative working cycle (write a test, watch it not to build, ...) - The systematic approach to get legacy software on board Good balance Good balance - Infrastructure stability could be improved - there is some duplication in the videos; avoiding them may allow to spent more time in the homework to continue the exercises or on the bonus material - in the videos with the live recordings of other training sessions the voice of the trainer sometimes is not to understand (e.g. if standing at the whiteboard) and the voices of the trainees are not to understand in most cases Very Good They are totally OK for me Yes to get the time by the project managers (line manager is already supporting ;-) Show
TDD for Embedded C Very Good Moderately Yes Good balance Good balance Excellent Knowledgeable, get the point across very well No - researching how to use for PLCs PLCs Show
TDD for Embedded C Excellent Much better Yes how test code and product code grow from step to step Good balance Good balance it's very good Excellent very good very experience yes. we have a project that we can use it how to generate test code from requirement Show
TDD for Embedded C++ Very Good Moderately Yes The usefulness of pair programming Good balance Good balance The Covid era is challenging but an in person training would be better Very Good Very knowledgable and helpful Institutional inertia will prevent quick adoption Leadership will to make these techniques required. Show
TDD for Embedded C++ Excellent Much better Yes A different perspective and methodology for doing code development Good balance Good balance Very Good Depending on timing a look at how the exercise can be solved No - we would have to work with a variety of people who were not part of the class to get this integrated into our development process. Training - we use off shore developers as well as in house. Show
TDD for Embedded C Excellent Much better Yes Applying the walking skeleton approach to TDD. Good balance Good balance Very Good My company is already using TDD. None at this time. Show
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