Youtube comments of Lee Rothman (@leesoftwareengineer).

  1. How many wtf’s per minute is normally a good indicator 😂. When you open a repo and it reads like you’d expect, that’s a good day in my book.
    28
  2. Totally agree with the statement that those who don’t like TDD have never really practiced TDD. I often find that more senior developers are more resistant to adopting this (and other XP) practices. Sometimes I just think it’s an issue with egos. In my 10+ years of getting teams to adopt TDD and CD not one team has gone back to their old ways, surely there is a good reason for this.
    17
  3. You took the words out of my mouth. 100% agree, invest in your staff and build an environment where they want to stay. Give them more of an influence as their time at the organisation increases. Give them profit share or shares in the company. Don’t treat them as a necessary evil to keep the company going.
    14
  4. I've been practicing TDD for over ten years and I can count the amount of bugs that have been released on my fingers. So how much time do we spend fixing bugs, well next to none. So more time delivering features for our stakeholders then. We also don't suffer from legacy code issues because we can refactor our code with complete safety. We can upgrade packages and framework versions and know that it all still works. Software changes over time (shocking I know) as we get more features or changes to existing features. If you can't deliver these changes in a small quick incremental way you will suffer from delivery taking longer and longer and longer. You will never really be agile in this space. I hear the same old same old arguments about TDD taking longer etc. Writing more code does not mean it takes longer. How long it takes for a developer to commit code is not important, it counts for nothing. Being able to deliver it to your users/stakeholders is the only time you add any value. Getting another team or a QA in your team to test when you've 'finished' development does take longer. On a slightly different positive, I've never worked with a bad developer that follows XP practices, however I worked with many that don't.
    12
  5. One other point worth mentioning is that if you write your test after you will never see the tests fail. If you don’t see it fail how can you be sure it’s correct? Been many times a unit test has passed before I’ve written the implementation due to not configuring a mock correctly.
    10
  6. Reads like a post from someone who has never practiced TDD to me. If your tests are tightly coupled to your implementation then something is wrong. You’re not just ensuring the implementation works but that your solution design is loosely coupled and you have separation of concern etc. It helps that when things do ‘come together’ you have clearly defined boundaries. You don’t need to know the overall design of the final solution to practice TDD, far from it. Try starting from the actual business/domain logic and work out from there as this is the most important part of the application.
    8
  7. Great video, however I do take issue with the comments in the code statement. Please don’t use comments devs, extract your code into small methods with meaningful names. Your unit tests will also be your documentation, and we are all practicing TDD aren’t we. Clean code and agile are a good match.
    7
  8. Yes because running the application locally and stepping through your code with a debugger is sooo much more efficient. Your prototype will gradually evolve and grow in complexity and then you’ll need to refactor, but you won’t because it will break.
    7
  9. When I faced this issue I doubled my estimates because I needed to test my code with a debugger and not a unit test. They soon come round. Ask your managers if they want their developers to be fixing bugs or delivering functionality to the stakeholders.
    6
  10. It’s just a look, the reality is they don’t give a feck.
    5
  11. I agree, so don’t document either then. That will just become outdated and stale too. In the main just don’t bother, what problem is this trying to solve? There could well be a better way. In the case of other developers understanding the code base then pair or mob. If two people understand it easily then it’s probably the same for most.
    5
  12. Agreed. If that’s not an objective of any development team then I’d be seriously concerned. If not they’re deliberately creating something that’s hard to change and that’s kind of important in software. Unfortunately it’s an all too common thing.
    5
  13. Wow, using logging to debug an application. It’s like it’s 1995 again. Watching this I get the impression that a vast amount of time is being spent on bugs, not writing new features for users. The comment about principles and design patterns are language specific I’d also challenge. I’d say that some of them are specific for language paradigms not for each language. The reason for refactoring code into small private methods is so you don’t need to go and look at the detail of what it does, because the name of it will convey what it does. Having said that it can be overdone at times, easy to refactor it with the powerful IDE’s we now have.
    5
  14.  @joanvallve7647  Personal experience isn’t really going to give you anything other than an opinion. Scientists repeat their findings multiple times to confirm their results. Then they submit their work to be published. This is so other people in that field can scrutinise this work and tear it apart and debunk it (or occasionally not). I often find most people’s decisions and approach to software development are just opinion based and not based on data and facts. I’m not sure why our industry doesn’t take lessons from this approach?
    5
  15. One piece of advice I give to other devs is to learn the IDE shortcuts. The amount of time I see devs taking their hands off the keyboard to use the mouse for everything really slows them down.
    5
  16.  @Marck1122 Don’t write stupid automated tests then. Write meaningful automated tests that covers all the logic.
    4
  17. Errr I think you’re missing one of the major points of test first. Tests after will not help you with the design because it’s already done.
    4
  18. Sorry but I disagree, developers are responsible for the quality of their work not management. I still see teams wanting permission to do things the write way, I’ve no idea why. Just do it, if a product owner or manager asks you to write a dirty hack say ‘no’. I know that some people do put a lot of pressure on developers to always choose the crap hack option, but they are not responsible for the quality of the code, developers are.
    4
  19. I’d suggest that if you’re regularly finding bugs then comments are the least of the problems.
    4
  20. I like the way you come up with a well thought out argument and backed it up with evidence. #flatesrtheralert
    4
  21. Agreed and also guilty. I’m going to try and change my workshops and use TDD in them. I think it will suit some subjects better than others? A session on refactoring code to use design patterns would be a good use case I think? I’m sure it will make attendees more confident in TDD in general?
    4
  22.  @traveller23e  Abstracting to depend on interfaces helps separate out the work load in a team so more devs can work on it, leading to quicker delivery. It also makes unit testing (particular TDD) much, much easier. Surly extracting away things that have separate concerns reduces cognitive load?
    4
  23. Writing tests after kind of defeats the point. TDD will ensure you have a better design. In addition you can only ever be 100% confident in your tests if you’ve seen them fail first. This is the key to unlocking CD.
    3
  24. I do like his quote ‘comments are a failure in expressing your intent with code’.
    3
  25.  @eyesopen6110  These types of posts is like having a discussion with flat earther.
    3
  26. Small incremental changes to the legacy code using the strangler fig pattern will allow your legacy code to evolve into well designed and easy to change code.
    3
  27. IMHO most base their decisions on opinion not data, which is unfortunate. Data > opinion.
    3
  28. Well if you mean most companies don’t implement best engineering practices whilst they ‘think’ they’re agile I agree. However that’s not a problem with an agile framework just a bad implementation of one. Sprints don’t lead to bad design, lack of good development practices does.
    3
  29. Try using the strangler fig pattern to gradually extract away the existing code when it needs modifying.
    3
  30. Instead of slow reviews try pair/mob programming. Even if you still need an approval for compliance reasons, this takes no time at all.
    3
  31.  @Max-wk7cg If they had used canary deployments then they would have limited the impact to the first batch of deployments rather than this mess.
    2
  32. And that’s a reason why you do canary deployments. Don’t deploy an update worldwide in one hit.
    2
  33.  @krux02  Complex requirements doesn't automatically lead to a hard to read implantation. Breaking something down into smaller, simple easy to understand steps is not unusual and part of an engineers role. I know that there are some very specific domains where that might be harder to achieve, but not most business apps in my experience. One shouldn't necessary lead to the other.
    2
  34.  @stevenleonmusic 💯I have yet to find any correlation between comments and code readability. However code that has been continuously refactored to make it clearer and has meaningful tests etc does have a high correlation. 🤔 I wonder if there is a way of using a code analysis tool finding technical debt and the amount of comments and quality of tests?
    2
  35.  @Marck1122  Well I can’t think of logic you can’t cover in an automated test. Maybe I’ve just been lucky in the time I’ve adopted practices like TDD and CD? Can you give an example and hopefully there might be a way to automate? The only code that I can think of is the look and UX of the client-side, the functionality of the client-side is though.
    2
  36.  @rui1863  Agreed. I’ve heard it described as ‘the language of violence’. ‘You must complete all the stories that you committed to during sprint planning’, ‘you have to increase your velocity’, ‘if you don’t deliver this functionality then you’ve failed the sprint’ etc etc. It’s often used as a shitty stick to beat people with. I still think that the main problem is a bad understanding of what agile is. I’ve posted on here before about Martin Fowler wrote a blog years ago and labelled it as ‘flaccid scrum’. Some think that because you have a sprint board, use story points and have a standup every morning then they’re agile. If you’re not doing the whole engineering excellence thing then you ain’t agile. I much prefer kanban to scrum personally. No planning an iteration worth of work, just the highest priority item, no sprint goal. As for the use of the word framework, I’m just quoting the scrum alliance definition. ‘As an agile framework, scrum provides………’
    2
  37. Testing shouldn’t be a separate process after the code is written, but whilst the code is being written. The state of devops report shows that lots of small releases results in fewer issues than a releasing lots of changes in bulk.
    2
  38. As I’ve already touched on in an earlier comment, I think most approach’s to software development is often based on opinions not on anything concrete. Why do we not take lessons from the scientific community and use experiments and observations (sounds like agile to me) to influence decisions on the way we write code? Science had their Age of Enlightenment back in the 17th century, when will get ours?
    2
  39. To me that’s plan and simple micro management. It doesn’t matter what practices, approaches you and the team want to try if they want to dictate then they value their opinion over outcomes. This will inevitably lead to a toxic environment from my experience. Unfortunately this is all too common. Have faith in your abilities and I hope you find somewhere better.
    2
  40. Maintaining automated tests is a lot cheaper than fixing bugs and spending half your time debugging. Teams that follow XP practices spend more time writing new features because they not fixing bugs.
    2
  41.  @joanvallve7647  Comparing objects like this (hardware) to software isn’t really a useful comparison. They are not put in to the hands of users in an iterative process. The most efficient way to develop software is not waterfall, but agile. Not fake agile that doesn’t adopt best engineering principles, real agile where teams follow XP practices. The benchmark for good software isn’t just that it works (any fool can get software working), but that it is easy to change for all developers ie readable and simple to understand.
    2
  42.  @joanvallve7647  if your unit tests are tightly coupled to your infrastructure then that’s just down to badly written tests, not something wrong with TDD. Try getting the right experience people working on it 😜. Again high test coverage being used as an argument. That is not the reason behind TDD it’s a beneficial side effect. Infrastructure changes and changes to domain logic are separate concerns and will have separate tests. We could go on like this for months, let’s just agree to disagree shall we? You’re comfortable in your approach and I am with mine.
    2
  43.  @joanvallve7647  OK then let’s not, fine by me. So where is your evidence then? You say it’s been ‘empirically proven’ so show us the evidence to back this statement up.
    2
  44.  @joanvallve7647  It’s not the truth unless you have evidence to back up any of your rambling BS. It is being adopted because otherwise we wouldn’t be having these messages on this channel about this video. That is the reality, you can keep on saying the earth is flat all you want but provide evidence for it, but you can because it not true.
    2
  45.  @joanvallve7647  Well when there are comments about code coverage I’d say that the title of the video is spot on.
    2
  46. That’s on code already written. He’s not saying remove old comments on hard to understand badly written code in legacy applications. Don’t use comments on new code, write clean easy to understand code not tomorrow’s legacy code.
    2
  47. Certainly one of the benefits. Personally I think the biggest benefit is having no fear of refactoring code. We all know that over time code changes and gets added to and becomes difficult to read and understand. With unit tests you can refactor code to make it cleaner without fear of breaking it.
    2
  48. Unfortunately I think this is by far the most common experience that developers have. People seem to think by using agile boards in tools like ADO & jira, having stand up meetings in the morning and retrospective meetings every week/fortnight makes you agile. If you’re not adopting the engineering best practices that underpin agile and you’re not delivering functionality frequently to users and getting feedback then you aren’t agile.
    2
  49. That’s nothing compared to the Permian mass extinction event 250 million years ago. An estimate 96% of species were wiped out.
    1
  50.  @Max-wk7cg  Well I’d like to hear of a reason not to do it in their situation. If they’ve not heard of it then I’d really question their engineering team. It’s not a new thing, here’s a post from 10 years ago https://martinfowler.com/bliki/CanaryRelease.html.
    1
  51. That’s what a CD process will help with.
    1
  52. Said the developer who has never done it. Development teams that follow XP practices deliver quicker.
    1
  53. And how many times do you release then? Only running test before release will result in a slow feedback loop. Sounds more like waterfall than agile.
    1
  54. ⁠​⁠@luke5100What specifically do you have an issue with? To answer your questions I’ve been writing software for over 35 years. I work in a team that practices TDD, pair programming and CD so I think that they are good practices for software development?
    1
  55. @luke5100apologies I miss read your comment. I’ll now Stand down 😜
    1
  56.  @ndewet  Well there’s certainly been loss of life due to bugs. NHS systems didn’t sent out letters to patients to book follow up scans for breast cancer. You can guess the outcome for some of those patients. Toyota had break failures in 2009 which resulted in deaths, caused by a software issue. Several suicides have been linked to the horizons scandal. Self driving car caused the death of a pedestrian 2018. I’ll stop there. 😢
    1
  57.  @alexaneals8194 That just sounds like putting the requirements as comments in the code to me? We have better tools to capture this data.
    1
  58.  @alexaneals8194  Well that might be your reality, but it certainly isn’t mine. Writing & reading comments isn’t going to stop bugs, automated testing will do a much better job (especially if you practice TDD). Those tests will also let all developers know why the functionality is there. If comments are so important then why do IDE’s grey them out by default, they deliberately make them fade into the background for a reason. The application requirements are not just for developers they are for the whole team to discuss along with the stakeholders, how do you do that if is distributed all over many code files?
    1
  59.  @alexaneals8194  Not sure if the comments would correlate with the bug count. It’ll be interesting to get data on that to see if it does? As far as automated testing being implemented correctly I’d say that is most people’s experience TBH. I have worked in plenty of teams that do implement XP practices properly (as opposed to paying lip service to it) and the bug count has come down nearly 0 (0 for six months in one team recently for example) and time to prod has decreased by 66% (same team). As you highlight though it’s got to be done correctly. You need someone with real experience doing it to mentor and guide them. It can be a bit soul crushing when an effort in changing a team’s ways of working doesn’t have a positive outcome. On the flip side when it results in metrics like above and they can code, refactor and release without fear, work on new features rather than bugs then it’s a happy team and happy stakeholders. It can be done, I’ve seen it, I’ve been doing for the last 15 odd years out of my 35 years of writing code.
    1
  60. Totally agree. I can probably use the fingers on one hand to count the amount of times I’ve used a comment in the last 10 years or so. Funnily enough that’s about the same I’ve been practicing clean code & TDD.
    1
  61. I’m linking the ‘stinking’ references to Treasure of the Sierra Madre/Blazing Saddles/The Monkeys/etc ❤️
    1
  62. You have bugs then, enough said.
    1
  63.  @trappedcat3615  If you write a failing test first then write the code to make it pass, then I’m not sure how it can be wrong? If you mean that the result you wanted wasn’t correct then your requirements were wrong. That’s not a problem with the test, that’s a problem with the process of gathering acceptance criteria.
    1
  64. The main points here covers canary deployments which would have stopped the deployment to most of the 8.5m affected devices. Further information shows that the fault was with one of the data files containing nothing but 0’s. There is no validation of the inputs to the kernel code so it crashed. I’d say that it was most definitely a fault on their part and easily avoided.
    1
  65.  @daydays12 Looking for tractor porn no doubt 😂
    1
  66. Read the state of DevOps report. There is a correlation between the bigger the size of change that is deployed the bigger the failure rate.
    1
  67. What’s debugging?
    1
  68. ‘Agile project managers’ sounds like an oxymoron to me 😀.
    1
  69.  @Storytelless  You’ll never get the early feedback by testing after. Your design will have already been done by then. You’ll never be 100% sure that you’ve covered all scenarios by testing after either, a coverage tool will only tell you if a test executes a line not that anything is asserted. One other drawback is that if you’ve never seen your test fail how can you be sure it’s correct?
    1
  70. African swallows are non-migratory
    1
  71.  @SteveBurnap Yup agreed. Have monitoring calling every x seconds to check that it’s getting a successful response.
    1
  72. Shouldn’t acceptance criteria be agreed on before a user story is worked on? Otherwise your going to be writing something that the user doesn’t want? I also don’t really think that the users really cares about the implementation either. With TDD you are running the code to see if it works, that’s what the tests do! How else are you running it? Though a UI and a debugger? That just slows you down.
    1
  73. I just caught up with his update, definitely worth a watch to understand what’s going on with software running on the low level.
    1
  74.  @carstenbohme8813 It’s a fair challenge. Teams get a chance to change their ways of working at the retrospective meeting and frequently modify things, but abandoning TDD hasn’t been suggested.
    1
  75. I have another four letter word that’s a better fit.
    1
  76.  @adventureswithlils4331 I think you have a misunderstanding of the word dogma.
    1
  77. @ Science doesn’t use dogma. It uses the current best reasoning based on repeatable experiments that have confirmed said hypothesis. Hypothesis must have rules so that they have falsifiability for example. Dogma is a belief held definitively without the possibility of reform. It remains unchanged despite evidence to the contrary.
    1
  78. @ I did, it was a new one for me so thank you. However originally it’s a name of an article published in Nature by Francis Crick. He later wrote “As it turned out, the use of the word dogma caused almost more trouble than it was worth. Many years later Jacques Monod pointed out to me that I did not appear to understand the correct use of the word dogma, which is a belief that cannot be doubted. "I just didn't know what dogma meant”. This is expanded on in more detail but you get the gist.
    1
  79. It could have yes. Initial deployment should have been a small amount of customers. It’s easy to set up monitoring so an external systems checks something like a health check endpoint. If it doesn’t get a successful response then something has gone wrong and stop all further deployments.
    1
  80. That sounds like an opinion based argument rather than a data based argument to me. Start capturing story cycle time with and without TDD and you'll have the data you need.
    1
  81.  @krumbergify  What are these bugs you speak of?
    1
  82. 😂 Shame that he was wrong then. Don’t get me wrong he was a genius but ultimately his theory of motion/gravity only holds true to a certain point. Einstein’s work superseded that of Newton.
    1
  83. Maybe those details should be linked to the story that it was committed against?
    1
  84.  @alexaneals8194 I’d say it was common practice to link every commit to a work item so it’s easy to find with your version control tool and work planning tool? If you want to know what specific scenario a piece of code was covering then your well named unit test will tell you that. You do write tests don’t you?
    1
  85. There never was an even distribution, even if there was you know that there is plenty of scope in between these extremes right?
    1
  86.  @joanvallve7647  What facts are you referring to? Can you send a link to published peer reviewed research paper for us please? Agree with your views about scrum. Most places I’ve worked don’t really do scrum in that they do not adopt the engineering practices that are at the core of agile. If you’re not adopting these practices you’re not agile. It’s been ambushed by non technical people and think it’s about management. The original signatories of the agile manifesto are software developers, so that should indicate what’s at the core of the idea. These are the same type of engineers that are frustrated when companies/people use the word ‘scrum’. I’m with them. This video explains it better than I can, https://youtu.be/3cmY-OFuuCw?si=cdHxF0KkeZLUDeAr
    1
  87.  @joanvallve7647  More than 15 years so you got that easy to lookup piece of data wrong. So you use the statement ‘Almost no one’, what is this based on? Some data published somewhere? How long something has been around for and the assumption that almost no one uses it is not proof. You can’t just dismiss something and come up with your own opinion as fact. That’s what some religious people do when arguing against scientific findings like evolution. As I’ve asked before get some evidence to back up your argument, if not it’s just your opinion and nothing more.
    1
  88.  @joanvallve7647  How you get to the statement ‘software industry is stupid’ is beyond me. As for evidence that the practice of TDD is a positive thing, if you watch the video studies are quoted that back this up. There are more studies out there that also produced data that would indicate this, I’ll get the links if you want? In the mean time perhaps you can share your data with us?
    1
  89. These people who don’t like change are in the wrong industry I’d say 😃
    1
  90. Don’t forget the DOS drives that were not really drives, good old ram drives. A massive performance increase for database access, expensive though 😂
    1
  91.  @alisdairmclean8605 She’s absent from a brain.
    1
  92. He isn’t the problem. People see this and vote for him, they’re the problem.
    1
  93. ⁠​⁠ @asfdadfgdasfh4444 The test will exist because they are explaining a behaviour that is required. If anyone is questioning why a test exists and if they are complete etc then that would indicate the tests are being written after?
    1
  94.  @Rope257  💯%
    1
  95. What the heck has agile got to do with the amount of time in meetings? Just goes to show that most people’s interpretation of agile is way off the mark.
    1
  96.  @eyesopen6110  What don’t you understand? You equate agile with meetings, why?
    1
  97. That sounds like defensive coding? I’d rather not spend time maintaining defensive code. Good unit testing (yes TDD) will ensure that you’re never passing a null. Using the result pattern or null object pattern will mitigate having to check for nulls everywhere which makes life easier. I’d also avoid throwing exceptions too, they’re expensive and are just goto statements with knobs on.
    1
  98. Same company also bricked Linux systems earlier this year (Debian & Rocky). However it feels like they need provide another way of accessing the kernel to make it more robust.
    1
  99. That’s not how it really works is it. Prove to us that you’re right.
    1
  100.  @TheEthanEdge  Sorry didn’t realise I was debating with a 5 year old.
    1
  101.  @TheEthanEdge  My first post was to the original post, Apologies, I thought the reply was from them. I think we’re aligned (I hope). So to the OP, theories are published so that other people in that field can confirm or disprove that theory. Over time we get more and more accurate as more experiments and observations are published and we get to an even deeper understanding. It’s never claimed we have the whole picture otherwise science would stop, but science never stops. If you think the universe has existed forever how do you explain the red shift in stars and galaxies moving away from us? Rewind that and they were once in the same place in space time as a singularity. If you have evidence that can disprove it then go ahead. Evidence though not an opinion based on nothing what so ever.
    1
  102.  @NicodemusT  As you say nothing is infallible, but tests give us early feedback that something failed. Should we just release our changes to production and cross our fingers then? AI will be another tool for software developers to use that will speed up development. Will it totally replace developers, in its current state I really can’t see it.
    1