Youtube hearted comments of Daniel Sandberg (@ddanielsandberg).

  1. 1. Scrum master was never supposed to be a position or a title. It was supposed to be a role that was rotated within the team each sprint of 6 weeks. 2. Most scrum implementations ignores the technical practices that are required to make it work in the first place. 3. Installing Jira, sprinkling a bunch of burnups, burndowns, story points, sprints, stand ups does not make anyone agile. 4. Stand-ups is not meant to be a reporting function, it's a sync meeting around "what is the most important things to focus on/resolve today?". 5. Story points are BS by and for people not doing the job. 6. And then programmers end up hating agile because they've been told that their dysfunctional scrum is "agile". 7. And no one read extreme programming explained or the agile manifesto, and the second page is totally unheard of. As Ron Jeffries said "I like to say that I may have invented story points, and if I did, I'm sorry now." PS. Don't mention SAFe - the devil's spawn by the old waterfall and RUP people. Pyramid scheme.
    317
  2. Git was invented by Linus because he's the author of the largest (and possibly most important) open source project on the planet, with tons of contributions from people all over the world, so he wanted to slow development down.
    3
  3. Why would that happen? With TDD we take many small steps and make many small tests. While the task/feature may be incomplete, the build passes the tests. public void sortNothingShouldReturnEmptyList() { assertThat(sort(null), is(emptyList())); } and write some production code that passes the test... You can commit that if you like, but that would be silly unless it's lunch. :)
    3
  4. I had written a long answer but I decided to delete it, because there is no point in arguing with someone that has already made up their mind and are actively trying to not understand. That you even write something like "I am pretty sure this whole video is just a troll." is evidence that you are arguing from a point of incredulity and ignorance.
    3
  5. What if everyone took a few minutes every day to make the entire system better? What if when you see a log line could be clearer you just fix it? What if when you see a coworker struggling you help them (pair, ask, off-load, etc)? What if you are trying to fix a bug and spend 3 hours being confused by some code before figuring it out; and instead of just fix the bug and move on, you actually took 30 minutes to refactor so that the next person don't have to spend 3 hours trying to understand the code? What if everyone did that and the organization became 0.5% better every week? How much better would the organization be after a year? 20-25%? More than that! The effect is compounding (like interest rates) since every improvement leaves more time for the next improvement. And it also has an emergent property: it changes the culture to be one of *How can I make the life of my coworkers better* instead of *What's in it for me*
    3
  6. Yes, he knows about it. How do I know? Because this argument has been done 100s of times on his videos and the answer is still the same: If you have 10 feature branches in flight, and none of them are done and merged, how much changes on main? Nothing! So there is nothing to rebase because they are all isolated and thus not continuously integrated.
    2
  7. I'll just copy my comment from your "100% coverage" video: "I would like to recommend PyPI (PItest for python). It's a mutation framework that runs the tests, then changes the code and runs the tests again. If no tests fails the second time around, it is recorded as a "mutation that survived" and it will fail the build." Also, I would like to mention that TDD is not directly about testing. It's not even unit-testing. It does help us develop testable code with a bunch of automated checks as a nice side effect. I think it was Dan North that said "It should really be named Design Driven Development or Example Driven Development" which is why he introduced BDD. I would like to recommend these two talks by J.B Rainsberger. (Basically the "why" of TDD): https://www.youtube.com/watch?v=mbcV_Qdb7Ts The Economics of Software Design: https://www.youtube.com/watch?v=TQ9rng6YFeY
    2
  8. By following the practice of CI. 1. Pull and local build (make sure it works before starting new work) 2. Do work and local build (does my stuff work) 3. Pull and local build (is it broken after pull? me? them?) 4. Push 5. Watch the build in the build-system, don't walk away 6. If it breaks, you have 10 minutes to fix it (and promise to not break it again) 7. If you can't easily fix it, revert 8. If you skip some steps, broke it and went home, you buy the team pizza for lunch the next day Practices, principles and discipline.
    2
  9. Changes must always work. Incomplete features can be hidden in a bunch of different ways; from build profiles to deployment or runtime configuration, to customer opt-in "try the new layout" options.
    2
  10. As with everything, it's a skill and it takes time to learn. No different than new developers applying all the design patterns on everything - "pattern-induced design damage". It's kind of strange how many devs out there have no problem learning every shiny new framework out there, but when it comes to TDD and test-automation they don't take the time to build the skill (which may take years, like everything else) and then concludes that "TDD is sh*t".
    2
  11. It's scary actually. According to some "old IT/tech people on Twitter" the amount of programmers doubles every 5 years. About 10 years ago everyone went nuts with FB/PR/GitFlow and thus we can approximate that 75% of all programmers have never done or seen real Continuous Integration. Yikes.
    2
  12. Also. Why would it be the testers that are maintaining the tests? Let the programmers maintain the automated tests. Gojko Adzic has a video called "Sleeping with the enemy" that explains the mindset behind that.
    2
  13. 1. Continuous Delivery is not Continuous Deployment. 2. Merge to main is not a deployment to prod. 3. If you want a pair of eyes on every change - then pair program.
    2
  14. Short answer: 1. You can commit incomplete code as long as it works and doesn't break anything else. If it's complex, very WIP and "not yet usable" then disable/hide it somehow (usually a build/compile flags). Improve and refactor as you go. 2. You don't "check if it works at the end of each day", you check it ALL the time, you make a full local build every 5-15 minutes and then check-in the code and let the Build Management System validate you didn't screw up. That's CI! 3. It works just as well for changing existing code as well as adding new code (that will need to be integrated with the old code anyway). It will often be faster to deliver *because* you know it always works (whatever definition if working you're using). No "test phase", no "integration phase", no "long arguments if we can merge it yet" because it's already integrated, finished or not. Nothing is free and everything we know how to do takes time to learn. Meaning, going from "sit alone in a corner, coding for days on a personal branch" to "everything always works and check-in the code many many times per day" is hard. Working with TBD and CI practices takes practice, discipline, and code hygiene.
    1
  15. Yes, this is called "TDD ping-pong". :)
    1
  16. Let's say you have 30 developers, each with their own feature branch. Even if all of them rebases from master every hour - how many changes are integrated to the branches? None! They stay continuously isolated and you won't know which branches that conflicts which each other until one of them is merged into main. CI/TBD is about exposing conflicts early by continuously integrating into mainline. It's nothing strange. What is strange is the obsession with branches to isolate changes and hide systemic issues.
    1
  17.  @cheebadigga4092  You still won't know that there is a conflict UNTIL some branch is merged into main and the other branches are rebased. That's it.
    1
  18. So instead of actually trying to understand and argue the point, you resort to ad hominem attacks?
    1
  19. What are you trying to say? It's not like Dave doesn't know this and have been promoting pair programming for many years. Please explain your comment.
    1
  20.  @etherweb6796  I do not understand this answer! I was merely pointing out common misconceptions around CI/CD and TBD. Develop can't be your source of truth *unless* you are building immutable production artifacts from "develop" and testing *that* in lower environments. But then you can just skip it and call it "main". Anyway...
    1