Comments by "Lee Rothman" (@leesoftwareengineer) on "Continuous Delivery" channel.

  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.  @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
  11. 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
  12. 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
  13. I like the way you come up with a well thought out argument and backed it up with evidence. #flatesrtheralert
    4
  14. 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
  15.  @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
  16. 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.
    4
  17. 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
  18. I do like his quote ‘comments are a failure in expressing your intent with code’.
    3
  19.  @eyesopen6110  These types of posts is like having a discussion with flat earther.
    3
  20. 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
  21.  @Marck1122 Don’t write stupid automated tests then. Write meaningful automated tests that covers all the logic.
    3
  22. IMHO most base their decisions on opinion not data, which is unfortunate. Data > opinion.
    3
  23. 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
  24. Try using the strangler fig pattern to gradually extract away the existing code when it needs modifying.
    3
  25.  @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
  26. And that’s a reason why you do canary deployments. Don’t deploy an update worldwide in one hit.
    2
  27.  @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
  28.  @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
  29.  @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
  30. 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
  31. 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
  32. 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
  33.  @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
  34.  @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
  35.  @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
  36.  @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
  37.  @joanvallve7647  Well when there are comments about code coverage I’d say that the title of the video is spot on.
    2
  38. 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
  39. 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
  40. 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
  41.  @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
  42. That’s what a CD process will help with.
    1
  43. Said the developer who has never done it. Development teams that follow XP practices deliver quicker.
    1
  44. 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
  45. ⁠​⁠@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
  46. @luke5100apologies I miss read your comment. I’ll now Stand down 😜
    1
  47.  @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
  48. 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
  49. You have bugs then, enough said.
    1
  50.  @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