Youtube comments of Andrea Laforgia (@andrealaforgia).

  1. It's really cool to realise that even in the places that are deemed to be the "most dangerous", there are so many nice people, smiles and talks about love...
    269
  2. Questi ragazzi sono sfortunati nell'essere nati e cresciuti in un posto del genere, con individui del genere attorno, ma per fortuna hanno un professore così. Bravo prof!
    60
  3. 15:58 that's a very masculine yell
    25
  4. It looks like everthing said by Kolya should be written down and preserved
    18
  5. The guy in a red t-shirt clearly doesn't understand the meaning of the word "theory" for science. He clearly states at some point that it means "explanation" but he doesn't understand what that implies, given that when he talks about the car starting up he says "but that's a bad analogy, there are no theories involved there". Wrong, dude. Wrong. The reason a car starts up is a mix of scientific theories about electromagnetism and gases. If it wasn't for those theories, we wouldn't be able to design virtually anything we use today.
    13
  6. Great video (as usual). Dave, may I suggest that you improve the sound quality and remove some reverberation in the room? Are you far from the mic? In case, you should wear a lavalier mic.
    11
  7. Bravo, Saverio. Come sempre. In un periodo della mia vita, mi sono dedicato alla lettura di molti libri sulla Shoah. Ce ne sono molti (purtroppo per le vittime, per fortuna per chi dovra` ricordarle). Bisogna caricarsi di grande coraggio per leggere quelle storie. Bisogna farlo, pero`, nonostante le lacrime che necessariamente sgorgheranno dagli occhi. Si e` moralmente obbligati. Bisognerebbe modellare la propria vita sulla base del fatto che e` esistito un evento cosi` sconvolgente. Bisognerebbe visitare i luoghi, leggere le testimonianze, visitare i musei e "respirare" la sofferenza di quei tanti uomini e donne, che saremmo potuti essere noi.
    8
  8. "There is no manager in the world...", "Agile should be reconsidered"... okay, calm down :) Team Topologies has been written based on what works in the real world. I have worked in at least three companies where we had enablement teams and followed the models suggested in the book and it worked really well. My current company is also adopting that model. I am working in the Developer Experience team. I think you must have worked with some crappy managers (not uncommon) that have seriously burned you out, and that's a shame. Also, Agile is not Scrum. You can work in agile ways without sprints and story points. In fact, it's advisable, in my opinion, that teams do so. It's not Agile that needs to be reconsidered; what needs to be fixed is the "Agile theatre" in so many companies.
    8
  9. You don't "pull in" those changes. You and the other devs work on the same codebase (Continuous Integration <=> Trunk-based development). Working on the same codebase and committing micro changesets multiple times a day, you break down work more easily, hiding incomplete features behind feature toggles, and avoid merge hell.
    8
  10. Si sta parlando di simpatie espresse nei confronti di un dittatore assassino, che era già tale ai tempi in cui quelle simpatie venivano espresse. Stai difendendo l’indifendibile.
    7
  11. Giuseppe Uva non è stato picchiato ed è stato dimostrato.
    7
  12.  @RFalhar  The fact that metrics can easily become a surrogate for the value that they are supposed to measure is well known in business psychology. It has a name, it's called.... "surrogation". Look it up. Its natural consequence is Goodhart's Law: "when a measure becomes a target, it ceases to be a good measure". Harvard Business Review has published a good article "Don't let metrics undermine your business" and you can find many others along the same lines being published over the last 10-20 years. I have recently engaged in a fierce discussion with the creators of Pluralsight Flow to expose all the flaws in their product, which is going to be a boon for micromanagers who - as Allen says - "want what they can measure". It's not about opinions. Our industry has known the dangers of output-driven vs. outcome-driven for many years now.
    7
  13. TBD requires committing meaningful changesets frequently and your aim as a developer is to granularize big changes into multiple, meaningful subsets. The idea is that you break down your work into manageable chunks along the day. That way, it is basically impossible that a single TDD-ed changeset takes a whole day to write.
    5
  14. Enrico Giovanni Medri se un bambino ti sbuca davanti, non lo eviti neanche tu. Ha piu` probabilita` di evitarlo lui, a 94 anni, con tanti anni di esperienza alle spalle, che tu che sei un neopatentato. Sii piu` cauto nei giudizi, sei ancora un poppante.
    5
  15. Grande Ruotolo
    4
  16. The idea of “decent people” is interesting. I am sure anyone who disagrees with the current administration of a country being the right one wants to replace it with what they call “decent people”. When you do it with poll cards is one thing; when you do it with weapons is another, especially when they are an invader’s weapons. Berlusconi is old, tired, worn out. He’s almost 90, he does not reason very well anymore, and should seriously get some rest and remove himself from the public scene (it will never happen).
    4
  17. >Stupid short cuts, no organizing. That has nothing to do with mob programming :)
    4
  18. When things are too liberal, someone might start a project with their favorite toy, develop a whole system with it, and leave a trail of rubbish after they've left. I've seen that first hand and it's a huge problem. There is a lot of risk, for companies, associated with reckless technology adoption. On the other hand, it is also true that too much caution creates stagnation and crystallises people's skills. I've seen people that after 20+ years became totally unattractive to other employers. I guess it's worth having a process that does not prevent the adoption of new technologies but at the same time puts some governance on it. Finding the right balance is not easy.
    4
  19. Nobody is promoting releasing not-too-stable stuff. Quite the opposite. Not that CDel doesn't means that you must release after every commit to master but that you are able to do so anytime.
    4
  20. "Nel mezzo del cammin di nostra vita, mi ritrovai per una selva oscura..." ... that's the right verse.
    3
  21. Unit testing means testing small units of *behaviour*, so the granular bits we develop driven by tests are granular behaviours. There is no reason why the tests your write before the code should in any way tied to implementation. Just write tests to assess granular behaviours.
    3
  22. You are not supposed to merge a failing test into trunk. The atomic unit that you merge into trunk is code + its passing tests.
    3
  23. In a professional context, "enthusiasm for new toys" is a personal feeling, whilst "choosing a technology" is a collective action. The problem is how you bridge the gap between those two, i.e. how you transform your enthusiasm for new toys into a projection of tangible benefits for the organization you work for. There should be a dialogue of some type and a consent like that Aino was mentioning should mature. You might not know if there will be benefits, therefore you ask to experiment, but experiments must be controlled and with well-defined expectations, otherwise the risk of going off tangents is high. I've seen all of that in my career. Deciding on new technologies carries a lot of risk for organizations. A developer might leave after a couple of years, but systems written with a specific stack might survive them much longer.
    3
  24. New hires are complete strangers joining our teams all the time. We must have a process in place that allows them to become productive as soon as possible. Mob programming is great at making people feel welcome and productive as of day 1.
    3
  25. No, it's working together, it's communicating, it's collaborating. A meeting can be working together, but working together is not necessarily a meeting. A meeting is communicating, but communicating is not necessarily a meeting. A meeting can be collaboration but collaboration is not necessarily a meeting.
    3
  26. ​ @alexandersagen3753  there is absolutely no reason why master should be *protected*. This obsession about protecting master is foolish. Master needs to be releasable, but it's absolutely okay to break master from time to time, as long as we can quickly fix it (it's the principle of the Andon cord from Lean). Establishing convoluted workflows just for the sake of protecting master can lead to all sort of inefficiencies.
    3
  27.  @irenecelli6785  "guastafestE", not "guastafesta".
    3
  28. I've seen a lot of misunderstandings of TDD but yours wins! :D
    3
  29. I would say it differently: focus on repeatable and deterministic tests and avoid fragile and undeterministic ones. That way, you'll see that, if you focus on the left side of the spectrum, you don't need to go to other side. End to end tests can and should be avoided.
    3
  30.  @ZodmanPerth  who said that they should "blindly" adopt them? As an engineer, you must be aware of what the research in your field has discovered and make informed decisions based on evidence. Far from "blindly". This is true for every technical field.
    2
  31.  @ZodmanPerth in every field of the industry there is research showing what are the most effective techniques, ways of working, tools, technologies in specific scenarios. What Dave is doing here is showing you what good looks like. Exactly what the DORA survey does what the Accelerate book does, or what ThoughtWorks' tech radar does. Nothing wrong with that. Now, it's up to you how you put that advice into practice. Dave, and other experts, are not putting a gun at your head and forcing you to adopt a certain way of working. You need to apply your judgement based on your specific scenario. The fault for those engineers blindly applying those concepts is of those engineers. What Dave is doing is showing (not even teaching) good principles. You should thank him for that.
    2
  32. But you customers can start using those features straight away, even though feedback on those features comes a few hours/days later. The important thing is to always keep your system in a releasable state and optimise for complexity, so if anything needs changing, it can be quickly done.
    2
  33. The ability to communicate is a prerequisite for any sort of collaboration, even asynchronous. Mob programming is nothing different than working together. The team must establish a relaxed and psychologically safe atmosphere where everybody is free to think out loud and share.
    2
  34. I would argue that refactorings are the best use case for trunk-based development. If you are refactoring a large part of the code, you’d better ask other people to stop working on that code or you’ll end up with a disastrous merge hell. If you can organise a refactoring as small batches of work to be integrated frequently, definitely do it.
    2
  35. This is the real reason they wanted to take Kabul back
    2
  36. Once again, pair programming does not mean "working while there is a person watching every LoC over your shoulder". That is NOT pairing.
    2
  37. Nope, you don't need that. Adopt continuous integration, no matter what the size of a feature is. Big features should still be broken down into valuable slices deliverable frequently and continuously. If you adopt trunk-based development, you can hide any incomplete functionality behind a feature toggle (if there's no other way). The longer you stay on a branch, the later your changes will be integrated, the more serious will be your merging problems, the less confident you are that your complete feature is not going to break other stuff.
    2
  38. Not really. Wikipedia defines engineering as “Engineering is the use of scientific principles to design and build machines, structures, and other items, including bridges, tunnels, roads, vehicles, and buildings”. If you extend that to software, nothing dictates that you should be following a waterfall model.
    2
  39. >The question that everyone in business typically asks, and that mobbers tend to deprecate, is whether it’s enough better to justify the obviously high investment, along with the abandonment of just about all work done in parallel. Business folks often wonder that indeed. I guess these problems arise when two very different areas intersect: technical practices and people management. My answer to that is that it would be easier to understand if "everyone in business" stopped thinking of humans as machines. Making humans work in isolation produces a worse result than having them work as a group. We've known that since the dawn of time. Humans are social animals who achieve exceptional results by collaborating (whether it's chasing a mammoth or coding a new feature). Besides, there is no point in creating teams only to make team members work in silos. What's the point of making me build a spaghetti and marshmallow tower with my colleagues if then you want me to play in my little corner, with my headset on? In no other field, we'll be able to find teams that don't collaborate synchronously to solve a current problem (football teams, military platoons, surgical equipes). The business folks should therefore stop equating mobbing/pairing with typing. Working together means thinking more clearly, sharing knowledge, achieving consensus, creating better quality, getting higher job satisfaction, avoiding wasteful activities of synchronization and rework (which often happens with post-development code reviews) and ultimately saving time.
    2
  40.  @ModernSoftwareEngineeringYT  Should we change "Continuous Delivery" to "Continuous Deliverability"? 🤣🙃
    2
  41. The scale of the project and the number of dependencies should really be irrelevant, in order to apply TDD. In fact, presenting an example for adding two numbers is much more similar to the real TDD scenarios. TDD is for small problems and large problems can always be broken down into small problems. TDD is applied to small scenarios/behaviours to be tested in isolation. Then you move on to the next one, and the next one, and the next one.
    2
  42. Using branching for that specific activity is totally fine and probably the only usage that is acceptable. Branching is not necessarily evil per se. It’s a Continuous Integration anti-pattern, though, so to be avoided when you want to integrate often with other developers in order to deliver changes as fast as possible and avoid merge conflicts (typical of long-lived feature branches). However, bear in mind that the longer your speculative branch staying unaligned with master, the more it will diverge with the rest of the development hence the more likely it is that your speculative work becomes less and less relevant.
    2
  43. >(a) One HAS some other Engineer(s)* available to pair/mob This is the premise of working in a team, isn't it? There is a widespread idea that a team is a set of individuals working independently and only occasionally catching up. I've heard many times the argument "helping the junior members of the team slows down the senior ones who cannot complete their work". That's completely wrong. There's no "my work", "your work", there's the "team's work", so get the members of your team pair up and mob cause THAT is the premise of teamwork. If that condition is not currently achievable, work hard to achieve it. My thoughts about (1) and (2): It's another work culture problem. If you have a super slow local build, that's a big problem. You need to address that. As a developer, you must be able to commit to trunk with confidence. The trunk build is not where you verify your local changes, so any developer who does that needs a good slap on their wrists. Any company that allows gaming the system that way has a big cultural problem that needs addressing. I am not going to comment any of your remaining points, because none of them really contradicts what Dave proposes or creates scenarios where what Dave proposes is inapplicable. Those are not an indication of situations where PRs are a better solution. They only show situations where CI and CD are either not being implemented properly or using a completely flawed toolchain. The fact that PRs, in those specific contexts, might come more handy because CI and CD are done badly, is not a merit of PRs. Sorry, but you missed the point.
    2
  44.  @marianamoise733  cambierai idea il giorno che ti capiterà di innamorarti di una persona disabile. Perché l'amore può benisismo capitare, non te lo vai a scegliere.
    2
  45. Every complex collaborative work activity requires a certain level of communication skills. It's just part of the job. If people sit quietly and do not contribute or even pay attention, that's a problem. It's deeper than just what happens in mob sessions. It's a professional ethics problem. As part of the hiring process, it is crucial to explore the communication ability of a candidate and their attitude towards teamwork. I do think that there is an upper limit to the number of people who can work in a mob and, based on my experience, that's 4 or 5. Pair programming is good but only when pairs regularly rotate. Otherwise the problem is that pairs are going to cristallize, with people who either always want to work together or never want to work together.
    2
  46.  @soppaism  not even needed for that. Major groundwork can and should be done in a TBD way.
    2
  47. Then you were one of the lucky ones. According to the 2015 CHAOS report from the Standish Group, the percentage of failed/successful/challenged Waterfall projects is 29/14/57 vs. 9/42/49 with Agile. Huge difference.
    2
  48. Madonna che massa di decerebrati...
    2
  49.  @davidboeger6766  pushing stuff to master on a whim IS NOT what CDel prescribes!
    2
  50. I never understood why in LoTR they want to live like in the Middle Ages when they have magic and could just make quantum computers out of thin air :D Great video, Aino, thanks. In my company, I'm trying to establish a process based on Tech Radars (inspired by the work done by ThoughtWorks). It's much harder than anticipated. Defining how to evaluate new technologies, how to make them progress through rings, how to create consent and manage disappointment when a specific one doesn't make it. All hard tasks. Whether there should be a "final word" panel or it should be more democratic. How to justify when a technology moves to the "Hold" ring and gets deprecated, and the countless flaming discussions that could generate. Choosing technology frameworks and managing their life cycle is far from trivial. Also thanks for pointing us to Linda Rising's talk. There is an interesting book suggested to me on LinkedIn: "Immunity to Change", by Robert Kegan and Lisa Laskow Lahey.
    2
  51.  @NukeCloudstalker  It's not a problem of low IQ nor being stupid. Merging trunk frequently into the feature branches does not solve any problem. If developer A and B create their own branches and work on them for days, never merging work into trunk, merging trunk into their respective branches does not add any value. And if they do merge frequently into trunk, then what's the point of using long-lived feature branches in the first place? It's only added complexity: go straight into trunk. Yes, you can have the same level of safeguarding and tests that prevents crap from going into production. Integration is continuous, at that point, and the final (single) artefact is continuously validated.
    2
  52.  @NukeCloudstalker  >feature flags has little to do with CI Feature flags are a tool that can come really handy when doing trunk-based development (a prerequisite for Continuous Integration), but there are ways to avoid them. They are not necessarily a pre-requisite for CI. Saying, however, "they have little to do with CI" is wrong. >there's never been proper tests of whether any of the supposed benefits CI should deliver, are actually delivered You do understand that CI is a very old idea and companies have been implementing it for decades, right? Have you ever worked in a non-CI environment? If you have, then you know why and how CI has improved things. >you were the one throwing around that word like an insult I think you are killing your own arguments by appealing to idiocy or low IQ. It's the best way to lose any credibility.
    2
  53. Feature toggles. No, you don't need to change any code when you push it live. You can just switch a toggle on and that's done via configuration. You can avoid removing the feature toggle straight away from the code (which yes, would require a new production deployment). If you want, you can use the toggle as a kill-switch, in case of problems. It would allow graceful degradation for example.
    2
  54. >Isn't it a good workflow to merge develop into your feature branch at least once a day? No. If developers work on their branches for days, master will not contain any significant changes for days, hence merging it into your branch doesn't make any sense. >It's similar to CI It's not even similar. >but other people won't be disrupted by having to relearn changes of an unfinished feature. Team members always benefit from working on the most up-to-date version of the code. >For example, I rename a method and add a few similar methods and then remove some, I don't want to be used, after I'm sure, which are the best methods. Then add a "Don't use" comment. Isn't communication key in a team?
    2
  55. By adopting techniques like pair or mob (ensemble) programming, you can easily avoid formal code reviews and adopt continuous code review instead.
    2
  56. There are antipatterns with any practice and pair programming is no exception. But it's not a problem with the practice; it's a problem with the humans implementing that practice and not committing to that practice. What you describe is not pair programming; it's "pair programming theatre".
    2
  57. >it result in twice as much code being produced Simply not true. You write code, you need tests for it. Whether you write them before or after doesn’t change the amount of code produced.
    2
  58. Continuous Delivery is the material foundation of agility. Working agilely means collaborating with the customer by releasing valuable working software as frequently as possible, in continuous small batches. The needs of the customer are continuously evaluated and wasting the customer’s budget on potentially useless features is avoided. The tools/methods here are those that enable us to satisfy our customers via early and continuous delivery of valuable software. Do you know a better way of working?
    2
  59. >I think continuous integration is a good idea, but I think pushing directly to origin/main (or origin/master) is a bad idea. That's a contradiction :) It's not CI if you don't push directly to the main branch of development multiple times a day. Note that CI and trunk-based development are the same thing. >My preferred way of working is to split backlog items / user stories into small (mostly) atomic tasks that aim to introduce one small addition. That's great. >All developers are human and everyone makes mistakes. By peer-reviewing every single addition to the code base we catch these small mistakes early. Sure, and that's why CI is not removing the benefit of code reviews from the picture. It's only advocating a different way of reviewing code, through continuous code reviews that happen while developing, and not at the end. There are various disadvantages of having PRs at the end of development phases: it's extremely hard for a reviewer that has not been involved in the development of a feature to get a good understanding of what the code does. You haven't seen it working live, you only have a bunch of files to statically analyse. The risk is that reviewers only skim through the files for a superficial validation, trusting the creator of the PR (especially if she/he is a senior member of the team who knows the system well) and coming up with a "LGTM". This is were PRs can become really dangerous tools. It is much better to use pair/mob programming and continuously review the code while working on it. >The added benefit of this is that you get to read other people's code daily. Is that a benefit? Having to stop your development activities to read other people's code of which you know very little? >That is a great way to learn. Sure, but learning through collaboration is 10x better.
    2
  60. What a great man, Neil deGrasse Tyson is, and what a fantastic scientist.
    2
  61. >Saying one branching strategy is a bad idea is bike-shedding and missing the point of CI / CD. If that branching strategy is antithetical to CI, then saying that is a bad idea is perfectly legit. GitFlow is antithetical to CI.
    1
  62.  @secretluver  your point really doesn't make any sense. Sorry.
    1
  63. >shouldn’t someone have reviewed your code before you merged it into origin master? Yep. The guy sitting next to you in a pair or the guys sitting around you in a mob. Or, in today's pandemic terms, "sitting".
    1
  64. Scusate, lei chi e`? Si arrendi!
    1
  65. What a gigantic buffoon.
    1
  66. Sure but with feature branching you are slowing down the test of the integrated code cause tests are run on each branch independently. It's only when you integrate changes from different branches that you may discover problems.
    1
  67. I can tell you that some coding bootcamps (I've been a mentor in one of them) use pairing and mobbing regularly, rotating the bootcampers. It works really well.
    1
  68.  @madollamike  >so unless your team is comfortable with not being able to work solo Don't you think that "team" and "work solo" is a contradiction? >would you say continous integration isn't a good idea for your team? Continuous Integration is a good idea for the company. It doesn't cease to be a good idea just because your team is a group not able to collaborate.
    1
  69. ​ @madollamike  >If I'm on a scavenger hunt team we might decide to divide and conquer and check in at a designated meet up spot once an hour so we can stay on the same page and review our accomplishments. Do you really think that's a sensible way to carry out a scavenger hunt? I am not joking. I think it's a terrible example that totally shows why trunk-based development is indeed the best way of working.
    1
  70. There are plenty of examples on the internet when searching for "CD pipeline". Tools, however, are irrelevant. What counts is the principles.😊
    1
  71. If it's too intense, then you can inspect whether you are working at a sustainable pace. There are ways to perform mobbing effectively (frequent breaks/rotations, hard "let's call it a day" deadline, etc...)
    1
  72. I wouldn't want Ms Vasquez to be my enemy. If she happens to step on my toes, I will apologise.
    1
  73. Can you clarify how Git Flow would ever help companies to manage risk of change in codebases with poor test coverage? Cause if test coverage is poor, no branching strategy helps there. With regard to "one-size-fits-all": no one ever stated that. In every case, however, where GitFlow is used, then Continuous Integration can be used, because CI would provide a logical segregation of features that is equivalent to the physical one offered by GitFlow. Sure, every organization has different approaches to risk, and yet so many use the same techniques to manage it: feature branching, GitFlow, PRs. In virtually every comment from GitFlow fans I've heard "it's not a silver bullet", "it doesn't always work", "in the real world it does not work that way" and yet no real argument was offered to rebut what Dave talks about in his video. What are the contexts where CD is not applicable? (not provoking, just curious)
    1
  74.  @clickrush  >processes and tools cannot substitute communication and engagement with your coworkers. There is not one size fits all, no silver bullet is what I'm getting at. Again, this is a typical logical fallacy, black&white reasoning. Who ever said that CI is a "silver bullet"? CI is a way of working that has proven to be better than other ways of working to develop software. Period. No one has ever stated, in any books/resources/articles about CI, that CI is a "silver bullet". People keep rejecting CI and trunk-based development putting a lot of emphasis on communication, like communication were the only thing a team needs in order to deliver software. A team needs to be able to continuously integrate their work. That's the point. CI is not substituting communication and engagement with your coworkers. How is a long-lived feature branch approach fostering any communication, given that it's a way to hide your changes and silo your development? Developers adopting feature branches often do not communicate for days and days, only to discover problems at the time of merging their changes. >The beauty of git is that is doesn't inherently prevent you from merging or branching. I don't see that as a "beauty". This video is not about git, it's about GitFlow. It's different. >Saying that rule/methodology X simplifies things begs the question: Under what circumstance? How much do you know about CI, which has been going on for almost 2 decades, and all the studies about it that prove it's the best way to develop software we know so far? Read "Accelerate".
    1
  75.  @clickrush  >I wasn't arguing against CI generally. I was questioning the notion that one particular way of using git "represents reality" for all I see a contradiction there. CI does dictate "one particular way of using your VCS". The definition of CI is "practice of merging all developers' working copies to a shared mainline several times a day" so if you're not questioning CI, you shouldn't be questioning trunk-based development either, cause CI and TBD are the same thing. Nobody is saying that this particular way of using git represents reality for all. What has been said is that if you want to implement CI, you need to give up ways of working that are antithetical to CI, and GitFlow is one of them for the reasons exposed. You are still free not to do CI, though. >What may happen if you don't separate work into branches on the VCS level is that you are separating it on the code level. You introduce configuration and (ad-hoc) logic in your code base so you can accommodate staging environments, beta/prototype features and so on. Which means you need to test that code too, which means you blow up your code base just so you can avoid branching. Absolutely not. Have you actually ever tried trunk-based development + feature toggles? It's much easier than you'd think. When feature toggles are inactive, you can consider the code they hide as not there at all. Separating the code physically (feature branches) offers less benefits than separating it logically (feature toggles). The latter approach at least makes sure that the various streams of development are integrated, the former doesn't, and the longer those branches live, the more they diverge from each other and master, the riskier it becomes to merge them into master. You can switch features on in your specific test environment and do all you want. It's much cleaner and simpler. The ability to integrate work and the ability to test/release features are two different aspects of software development. Note that you say "you blow up your code base just so you can avoid branching". First, you don't blow up at all your code base, quite the contrary. Second: the purpose here is not to avoid branches, but to fulfil the definition of CI. The fact that branches are avoided is a nice side effect.
    1
  76. After suffering from two years of Covid pandemic, what we needed was just another catastrophic war.
    1
  77. Supporting legacy versions of your system has nothing to do with feature branching.
    1
  78. Working on local master lasts for a fraction of time: as soon as you small changeset is ready to be committed (which should be a matter of minutes), it goes in. You can't achieve that with long-lived feature branches. The local master is not really used as a branch. You commit+push all the time. I think you misunderstood: he is not suggesting keeping your changes on your local master for at most a day. He is suggesting integrating into the remote master (the shared mainline of development) multiple times a day. A feature can indeed be reduced to one day increments, even more than that: increments every few minutes. You can always break down a feature into small subset of changes. You can use feature toggles to hide unfinished features. You can work on parallel features in the same branch. No problem with that. You should, actually. You can test fully your changes before committing/pushing to master.
    1
  79. ​ @bitti1975  No one has ever said that, with pair programming, code reviews are expendables. Async code reviews are though. It all depends on what you mean by code reviews. If you mean PRs, yes, they can be removed with pair programming. Code review is a fundamental activity that you make continuous with pair programming. You shift left the code vetting, decision, agreements you would normally perform in a PR. The best way to review code is to make decisions whilst working on it, not after. There is a mountain of evidence that proves that pair programming is highly effective, and mob programming is even better.
    1
  80.  @gillscramble  When you test-drive development, writing a code for the test and writing a code for its intended use case are the same activity. The purpose of TDD is not to prevent bad tests. It's to allow well-designed code. >As I said, design should not be for the test. And all of your design properties are good, and the are good on their own. That is not true at all. In general, when designing a system (not necessarily just software systems), the testability of that system is a design requirement. You want a system that allows to be "probed" to diagnose any problems. Any complex system caters for some sort of diagnostic mechanism. There is a reason you generate logs in a structured format, for example. Take dependency injection: one of the advantages of using it is that you can easily mock the collaborators of the system under test.
    1
  81. Look at the number of dislikes to this video. F-----g scammers.
    1
  82. With trunk-based development, you don't find out after updating master. You can still validate your changes before pushing them to master. This video is about implementing continuous integration, which is something that you cannot do with feature branching.
    1
  83.  @MikaelGullberg  It is not "random garbage" and it is not "noise", those are incomplete features that will be completed at some point and that it is better to keep in the shared mainline of development, continuously integrated. The point that you cannot see is Continuous Integration, which enabled Continuous Delivery (the name of this channel).
    1
  84.  @MikaelGullberg  It's not garbage. Why do you keep calling the in-progress work of the team "random garbage"?? As I mentioned before, quality control is guaranteed by tests run before pushing your changes. Do you seriously think that anyone would suggest pushing unverified changes to the branch that is supposed to be the baseline for releasing to production? It's not noise. It's ordinary work. There's a big difference. CI stands for Continuous Integration. You integrate continuously by merging changes from all developers into the mainline of development continuously "all the time". You can't do CD without CI. Not sure why you think it's a "knee jerk reaction rebase". Trunk-based development is a very effective practice. Major companies like Google, Facebook, Amazon, HP adopt it on very large projects, with thousand developers and billion lines of code.
    1
  85. ​ @MikaelGullberg  There is a perfectly valid reason for committing straight to main (no longer "master") and it's called Continuous Integration, as explained to you over and over again. You are commenting on a channel called "Continuous Delivery". Have you realized that? It's not "freely committing", by the way. Companies like Google, Facebook, Amazon, HP, and many others (including some I've worked for), have been adopting trunk-based development for many years successfully. I am repeating this because you are rejecting the definition of Continuous Integration. That's it, then.
    1
  86.  @MikaelGullberg  Not sure what "justification" you're looking for. See above. It's called continuous integration for a specific reason.
    1
  87. I’m not sure where you got the idea that Beck turned TDD into a religion. He sent the exact contrary message in the video. It’s not a religion, apply it if you find it useful for your specific context. Not sure who the “TDD people” are. I see a lot of variety among people in the way they apply TDD. There are different schools and degrees of application of TDD. The idea is always to try what worked for others, see if it works for you. If it does, great. If it doesn’t…. great!
    1
  88. The fact that someone walks around with a t-shirt with the YouTube logo and the text "Truth" beneath it, speaks volumes.
    1
  89.  @sivarooban8438  1. No, there are ways to structure your code in a way that you don't end up in a mess (factories, strategies, proxy objects + dependency injection, etc..). Using specific techniques, you can make your code highly maintainable 2. You don't write test cases for feature toggling. You write test cases for the features you want to implement. 3. Can you give me an example of what you mean?
    1
  90.  @oliverthane2868  No it doesn't. If developers work on their own for days, without merging anything into master, rebasing off master doesn't add any value.
    1
  91. In your case, I think the only limitation is that your code will be releasable only after passing all those tests. But that doesn't prevent you from using a single branch for continuous integration. The changes can go in as switched-off features and be switched on only in the test environment.
    1
  92. 4:15 "Stay focused"... the irony
    1
  93.  @d3stinYwOw  Tests that are requirement-based can be easily automated. Have you ever heard of behaviour-driven development?
    1
  94.  @d3stinYwOw  but I was talking about automating tests via a BDD approach... are you just a manual tester?
    1
  95.  @d3stinYwOw  Sorry, I did not mean to be disrespectful :) The point I was trying to make is that testers (whenever present in projects) should actively collaborate with developers to automate tests as much as possible and reserve manual testing activities to exploratory testing. BDD tools can (and should) be used by testers too.
    1
  96. The point is not the final result.
    1
  97. It's America. What do you expect?
    1
  98. Why not activate the feature for testing and run the build on master?
    1
  99. So what happens when you have a client base of 1000s customers? Do you create thousand release branches? You only need to tag a version that you release to a customer. If you need to apply a hotfix, you can branch from that tag and, only in that moment, have a release branch. But that should be ONLY for hotfixes, not for continuous development and you should make sure that that code converges back into the main line of development asap. Maintaining hundred different development branches, one per customer, is absolutely not sustainable. CI stands for continuous *integration*. The definition of CI is "a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. By integrating regularly, you can detect errors quickly, and locate them more easily." Therefore feature branches are incompatible with it.
    1
  100. "when everyone has different things going on" That is not a team.
    1
  101. Non capisco come si possa essere così bestie da insultare una persona a questo modo (e insistono anche nei commenti a questo video). Voglio pensare che siano un brano di mocciosetti brufolosi e frustrati, guerrierucoli da tastiera che devono ancora prendere qualche bella tranvata nella vita, che li riaddrizzi Grande Ilaria, spero che la tua vita sia piena di sorrisi, amore e soddisfazioni.
    1
  102. Waterfall has never been the answer. There is a common misunderstanding in the industry that Waterfall is a “model”. No one — and I mean no one — in the history of software engineering has ever presented a “Waterfall model”. The idea that software had to be developed in subsequent phases was adopted by the US DoD. They never understood that what Dr. Winston Royce was presenting in his 1970 paper on how to manage the development of large systems was a model to avoid (he wrote something along the lines of “don’t do it this way, it invites failures”) and proceeded to explain how to produce those systems iteratively. He even mentions involving the customer in a very similar way to what the Agile Manifesto describes. Royce himself was a supporter of iterative and incremental methods. The industry understood the opposite and a “Waterfall model” dominated it for 20 years, until the adaptive methods reemerged and Agile was formalised. We have always knows, however, that software should never be implemented with a “Waterfall model”. Customers don’t need predictability. That’s an extremely common fallacy. Customers need a software that solves their problems. They only need predictability when needing predictability is the only option we give them. If you ask me for a software, and I tell you that you’re going to get it at some point in the far future, then of course you want to understand how long it’s going to take and how much it’s going to cost you, before you embark on a journey where you won’t see results for a long time. If, on the other hand, I agree with you to release limited-scope features continuously, frequently, so you can evaluate them, give feedback and adjust, limit your financial exposure, and decide, at each step, if you want to continue investing in the product or not, you are not going to need predictability. Remember: “Waterfall” was never a model for software development. We have known that software must be developed in iterative and incremental ways for 70 years now.
    1
  103.  @adambickford8720  If you are saying that a lot of companies implement a fixed scope + fixed budget + fixed time policy and they come up with hefty fees when you don’t deliver according to their fancy dreams, you are right, but that’s only because they have not yet understood the nature of software and insist on applying a model that DOES NOT work for software. The people demanding that way of working are the same that object to the (sensible) arguments against long-term estimates in software starting their sentences with “Well, if you build a house, you want to know…”. Software is not houses. Companies that adopt those contracts are not successful at delivering software. It’s proven by data. The 2015 CHAOS Report front the Standish Group collected data from the industry proving that Agile is 3x more successful than Waterfall and Waterfall is 2x more likely to fail, so yes, Agile is the right answer for software development. But, as I said, we already knew that. There are a lot of different agile contracts that can be adopted to implement software agilely.
    1
  104. Pairing/mobbing is not typing. It's thinking about problems together.
    1
  105. >if Kanban is not agile, then it must be waterfall That's a huge logical fallacy. An apple is not Agile. A foot is not Agile. It does not mean that they are Waterfall. As Ron Jeffries wrote: "is Kanban “Agile”? In a word, no. In a few more words, while Kanban can be used in an Agile fashion, its principles are not those of the Agile Manifesto, and it can be used quite effectively in a situation where the Agile values are not in place. It’s a really good set of ideas, very compatible with Agile projects, very likely to help you improve. But it’s not “Agile”: it’s an independent set of ideas. Great ideas." Something can be orthogonal to Agile - without necessarily be classifiable as waterfall - and be used effectively with Agile.
    1
  106. The value given by PRs is code review and with trunk-based development (i.e. Continuous Integration) you'd have continuous code reviews by people working together (pair/mob programming). It doesn't really matter how you call your main trunk of development, as long as that's the one where you continuously integrate and from which you cut off your releases. >continuous delivery of feature branches is also not super hard. "Continuous Delivery of feature branches" doesn't make sense. You deliver the code in your main branch of development. >I give it 10 years and one of the people giving this a like is going to come up with Git Discharge Dude, you really need to get your facts right. Continuous Integration has been going on for more than 20 years now, and lots of companies adopt trunk-based development, big players like Google and Facebook included. Seriously, before labelling something as "drivel", why don't you study a bit more?
    1
  107.  @larsthomasdenstad9082  >You are listening to and old dude spouting ideology. I am not dignifying you with a technical response (I have many that would totally destroy your arguments), because it's clear that you're a troll :)
    1
  108.  @larsthomasdenstad9082  >He doesn't understand software development, hahahahahahaha
    1
  109. Yeah right, tell Google.
    1
  110. I agree that the example at 46:12 is not great, but I don’t think it can be qualified a strawman argument. That chunk of minified code that Dave showed can be interpreted as just an exaggeration of a concept, similarly to a meme. The point is actually making relates to the code shown at 10:10, where most people seemed to agree that the code at the top was better than the one at the bottom.
    1
  111.  @SM-ok3sz  Oh please. That's not the takeway. The takeway is that working together, on the same machine, is possible. Colleagues are coworkers, not strangers.
    1
  112. Una donna così può affrontare qualsiasi sfida nella vita. Brava Ilaria, forte e coraggiosa. Un bacione.
    1
  113. 6:58 I could watch it all day
    1
  114. 2-3-4 days of development is not continuous integration. The basic assumption here is that you may want to apply Continuous Integration. No, master is not "just a place where there's nothing but merge commits with version tags", master/main is the shared mainline of development, the one where code from devs should be continuously integrated multiple times a day.
    1
  115. A single dominating voice is a problem for a team anyway. Something really orthogonal to mob programming. That dominance can manifest asynchronously as well, by silencing others’ contributions in many forms. How you avoid inadvertent, good-faith dominance is by rotating drivers and navigators and having regular sessions to discuss what can be improved. All teams are average. If people want to be the alpha male, fire them; if they are sorry they came across as such, work together to fix that. I’ve been a team lead many times in my career and one of my principles was exactly what you mention: trying to spot the weaker team member, and ensure they were included more and got properly engaged. I remember a retrospective where the only female member of my team bravely complained that she struggled intervening in discussions due to her psychology and the "alpha males" around her prevaricating. My job was to make sure that wouldn’t happen anymore. Companies must change the way they manage people: rewarding individual progress makes sense when individual contribution is required. That's not the case of software engineering. Companies must find different ways.
    1
  116.  @stevecallaghan7523  I'm not sure what a "typical process" is. I've always worked in places where it was my team's responsibility to delivery something, not the individuals in it.
    1
  117. ​ @stevecallaghan7523 >simply firing people for being an Alpha Male doesn't fly here in the UK I wrote that and I work in the UK. It's not "simply firing people for being an alpha male". I wrote "people who WANT to be the alpha male", which means people who disregard others, want to dominate, silence other people's opinions, do not value other people's contributions, etc. I'm sure that all these behaviours violate a good number of values in every UK company, no matter the field and, over time, manifest in nasty ways that managers are able to spot. Managers should be able to take corrective actions. UK companies have "Improvement required" evaluations which have a final point.
    1
  118. No. If developers work on their branches for days, master will not contain any significant changes for days, hence merging it into each branch wouldn't bring any benefits. I am not sure what you mean by "only working on local master". You use master as a temporary workbench: write some test-driven code. Push it. Repeat. What counts is that your code lands continuously on the remote master, which is the shared mainline of development.
    1
  119. A clueless team does not achieve any results with any way of working.
    1
  120.    When I talk about continuous delivery, I always think of complex flows. Continuously integrating changes into main/master and releasing features to production are two different concepts. Clearly, if you adopt an Agile way of working, you'd want to deliver as often as possible, but you can schedule releasing specific features, as long as they are present in the code but hidden behind feature flags. When you release a new version of your product, all you need to do is tag your code. You don't need to create a release branch at that point in time (tags are logical branches). When it comes to hotfixing v.1.0.0, then you can create a branch, apply the hotfix to main, apply the hotfix to the branch, release version 1.1.0 whilst main/master happily navigates towards v.2.0.0. But that branch is not for continuous integration. It's for hotfixing. And what you really want is to converge that version into the main one asap. I would much prefer continuously delivering and not having to maintain multiple concurrent versions, parked on side tracks for ages. If you have hundred/thousand customers, that model becomes unsustainable. So, yes, you can achieve what you mention by having a single branch for continuous integration and deciding when to release features as a parallel process.
    1
  121. Wow... your tin foil hat really works!!
    1
  122. No, Kanban, strictly speaking, is not Agile. As Ron Jeffries, one of the signatories of the Manifesto, wrote: "Is Kanban “Agile”? In a word, no. In a few more words, while Kanban can be used in an Agile fashion, its principles are not those of the Agile Manifesto, and it can be used quite effectively in a situation where the Agile values are not in place. It’s a really good set of ideas, very compatible with Agile projects, very likely to help you improve. But it’s not “Agile”: it’s an independent set of ideas. Great ideas." Consider that founding principles of Kanban originated in the 1940s, when Agile was not even remotely conceivable. Kanban is orthogonal to Agile and can be used with Agile, but it's not Agile.
    1
  123. You can use stubs to emulate the database or just use an in-memory database. It’s perfectly doable.
    1
  124. The aim should be to automate tests as much as possible. A human running tests plans with repetitive operations and deterministic results should be replaced by automated tests. Humans are best used for exploratory testing, where the human brain is what makes a difference. However, if you still need a human to look at the feature, you can do that anyway: keep the feature behind a feature flag and activate it in a test environment. A manual tester in that case is there to ensure the feature can be accepted for releasing, not that the code for that feature can go into master.
    1
  125. If you adopt pair and mob programming, code is continuously reviewed. Believe me, it works.
    1
  126.  @KaratePath  Continuous Integration is not a new concept. It's 30 years old and it's a pillar of Extreme Programming, which is also nothing new, being developed by that genius of Kent Beck starting from 1996 (the C3 project for Chrysler). Versioning is done via tags, branching doesn't help for testing more than trunk-based development does. What Dave talks about in his video is not an idea he came up with last night. He is describing what happens in the industry, with some big players like Google and Facebook adopting scaled trunk-based development (billions line of code managed by thousands of developers). This is not a practice seeking validation.
    1
  127.  @KaratePath  Pair and mob programming are not new concepts either.
    1
  128.  @KaratePath  you are more than welcome to work whichever way you like. Just don't claim it doesn't work for others. I don't understand the concern about privacy. It's about working, not watching porn.
    1
  129. ​ @KaratePath  Then take the breaks.
    1
  130. ​ @KaratePath  Having two people working on the same feature ensures that higher quality is delivered, work is finished quicker, knowledge sharing happens, and that people have higher job satisfaction. Work is not just about cold numbers. Delivering high quality means that the chances of bugs but also rework due to misunderstanding a feature are avoided => time saved => money saved. Work finished quicker means that more work can fit the same time span => time saved => money saved. Knowledge sharing means that the next time developers pick up a task, they are familiar with the code base, which means less time asking more senior members for help, so optimisation of work => time saved => money saved. Higher job satisfaction means that you'll retain developers longer, which means you won't lose valuable members of staff due to a suboptimal process, therefore having to hire someone new and spend time getting them up to speed => time saved => money saved. Shall I continue?
    1
  131.  @KaratePath  Read "Accelerate". You'll realize how wrong you are.
    1
  132. ​ @KaratePath  I NEVER said, thought, implied that my view is the only valid one. That's your interpretation. I don't care about persuading you but I won't let you deceive other people who might be interested in this topic. If you keep coming back with arrogant responses like YOUR view should be the mainstream's view, then you gonna get lots of evidence from me that prove you wrong. So keep insisting in your obtuse answers and I'll keep responding the way I am responding. Your choice.
    1
  133.  @KaratePath  No, your view is NOT the mainstream view. Go read one of the books already mentioned. You couldn’t be more wrong. Stop embarrassing yourself.
    1
  134. Code reviews are highly overrated. Have your team work as a real team via pair/mob programming and you won't need code reviewa and PRs. PRs were not meant to be used by teams of colocated, trusted collaborators.
    1
  135. As a former 3-year-old, I can understand where she's coming from.
    1
  136.  @michaelrstover  I don't throw out anyone. I try to make processes inclusive for everyone. Being capable is not enough, though. You must also be able to collaborate. Collaboration is a fundamental requirement in software engineering.
    1
  137.  @carveratutube  Before dismissing what Dave says, I encourage you to try to apply what he suggests. What Dave is suggesting is the best way of developing software today: TDD, trunk-based development + feature toggles. And it's not just his opinion. That companies perform much better by adopting those techniques is supported by facts (see the rationale behind DORA surveys and the book "Accelerate"). The idea that features must not be "not really nice or complex" because someone is suggesting working in small batches using TDD and committing often is fundamentally flawed. That is THE way you should be developing software today, especially in a large organization, where many developers participate in working on "nice and complex" features. Committing WIP in master is absolutely fine if you use feature toggles. TDD is not essential for CI, but it's a big enabler of CI, therefore no reason for not using it. There are billion reasons why you should be using TDD that are not striclty related to CI, so I suggest that you watch a video about it. There's plenty on YT.
    1
  138.  @BigCarso  No, that's exactly what is is: 10-15 mins max.
    1
  139. I can totally confute your point about CD being not realistic given that I have worked for many companies that implement it, and I know many others who do. Continuous Delivery is a well-established practice in many large companies. What is "daily CD"? Continuous Delivery does not dictate that anything should happen "daily". I suggest that you read Dave's book "Continuous Delivery". The book "Accelerate" is another good resource. Merging to trunk every day is another well-established practice that has been around for many years, and it's adopted by companies like Google or Facebook (plus some I've worked for), in a scaled version, where thousands of developers collaborate on billion lines of code. >What if I need to work on a module that takes me 40 hours of coding? Then Test-Code-Refactor-Push, Test-Code-Refactor-Push, Test-Code-Refactor-Push, for 40 hours. This is not theory. It's reality that's been going on for many years.
    1
  140. PRs are not strictly necessary for automation. The automated steps you attach to a PR can live in the build and deployment pipelines. What stops bad code from being merged is automated tests and code review, not Pull Requests. Code reviews can be performed in many different ways, for example continuously, when adopting social programming approaches. The more you dig down, the more you discover that no, there isn't plenty of reasons to use them. PRs were never meant to be used by durable product teams.
    1
  141.  @nextlifeonearth  PRs are not lights.
    1
  142. With CI / trunk-based development, that’s totally doable via feature toggles. You can logically separate those features within the same code base.
    1
  143. The aim should be to transform repetitive, tedious, deterministic manual tests into automated tests and reserve human brain capacity for what it can do best: exploratory testing. Not sure what you mean by "dirty branches". If you mean potential throw-away, experimental work, you can still have those branches, as long as they don't participate in your continuous development strategy. The problem with branches is always when you try to re-integrate them into the mainline of development after days or even weeks have passed by and main/master had diverged significantly. With regard to code reviews, you can have those with trunk-based development, either with short-lived branches or with something even better: pair/mob programming.
    1
  144. That's great news!
    1
  145. Yeah but this idea that a team is a group of people where there are untrusted members supervised by trusted member is really bad. It encourages ivory towers. A team should be a group of people working together: get the senior one join the junior one so the latter soon become trusted. Teams are there to unite people, not to segregate them.
    1
  146. Scenario 1: You can indeed have only 1 function in your code that will implement one behaviour or the other based on the version (for example, you could use the Strategy pattern there). No need to keep your code physically separated when you can have logical separation.

You don’t need to duplicate any other version of the code that the two libraries have in common. No need to fix bugs in that part of the code multiple times.

In general, you can use feature toggles to logically separate “branches” of logic in the same code base. It works really well. 
In some languages (e.g. Java + Spring Boot), leveraging dependency injection, there are some neat ways of injecting behaviours based on conditions that make the above very easy to do (look at how ff4j works, for example). 

Scenario 2: the longer code is parked on a feature branch, the higher the risk of diversion from master and merge conflicts. The best way to develop code we know so far is to continuously integrate into a shared mainline multiple times a day (e.g. Continuous Integration). See above: using feature toggles, you can delay releasing a specific feature as long as you want.

The big misunderstanding here is that each push to master will release to production. One thing is pushing to master, another thing is releasing to production. You can have that with Continuous Deployment. With Continuous Delivery, your code is always releasable but not always released. The key point here is that you must be able to release whenever you want with no fear.

 The reason why trunk-based development seems dangerous to you is because you’ve never used it. Companies like Google or Facebook (but I could also mention some smaller companies I’ve worked for) use scaled trunk-based development on extremely large projects with thousand developers on them. 
 What you describe in your last paragraph is not continuous integration.

Continuous Integration is defined as: “a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early.By integrating regularly, you can detect errors quickly, and locate them more easily.” (ThoughtWorks)
    1
  147.  @markar34  Of course I am aware of semver, it's a de facto standard. Semver is irrelevant though. You can use whatever versioning mechanism. I totally understand why you need to keep two separate versions of your library. That's a common scenario in any software, especially when you deal with "dinosaur" companies that move at a very slow pace and are reluctant to upgrade even when they would need to (e.g. big financial institutions). I don't think you understood my comment though. I am not questioning the logical separation of your versions; I am questioning the physical separation. Believe it or not, you don't need long-lived branches to maintain that separation. You can have a logical separation of versions within the same single branch. You can deploy from the shared mainline using different configurations for each client and each version. As I said before, if you have hundred or thousand clients, you cannot possibly afford long-lived branches for all of them. The ability to keep developing your software would grind to a halt. I mentioned dependency injection with regard to how to use feature toggles properly with some languages/frameworks, just to avoid the mess in the code that you were mentioning. Your code can be architected in a way such that the usage of feature toggles has a very minimal impact on it. Unfortunately, it would take time and a real example to show you how that works. The ff4j library is very powerful from this point of view, leveraging proxies and DI. >The fact that we share say, the develop branch, and our CI builds it, and runs automated tests, that's enough to say it's continuous integration. I'm not sure what is your definition of continuous integration. Nope. Not if you use long-lived branches. Continuous Integration, as defined by ThoughtWorks, is: "Continuous Integration (CI) is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. By integrating regularly, you can detect errors quickly, and locate them more easily." If your development happens on long-lived feature branches, it's not CI. CI doesn't just mean having a CI build. It's a development practice.
    1
  148.  @markar34  The definition of CI is not subject to opinions. It's clear. The word "repository" refers to the shared mainline (master/main/trunk/etc..). I can mention many other definitions that all lead to the same thing. For example, Google Martin Fowler's one. Continuous Integration wouldn't be such if there were multiple branches involved. It would just be a contradiction. The important bit is *continuous*. >Integration can happen in any other branches. I don't see why you can't see that as integration. I said that is not *continuous integration*, not that is not some form of integration. As Altassian correctly says: "In the trunk-based development model, there is a repository with a steady stream of commits flowing into the main branch. [...]trunk-based development is a requirement of continuous integration. With continuous integration, developers perform trunk-based development in conjunction with automated tests that run after each committee to a trunk. This ensures the project works at all times.""
    1
  149.  @markar34  >so what happens if you made a commit on master branch that fails the build? You validate the change before committing to master. Dude, go read something about trunk-based development. >With branching, you can prevent that Again: branching is not Continuous Integration. >What about code reviews? You can't force pair programming. You don't need to force any practice when the benefits are obvious. Pair programming or mob programming are excellent ways of working that emerge naturally in the right environments, with good engineers and the right work culture. They imply code reviews. Continuous code reviews are the best way to review code.
    1
  150. ​ @markar34  You did not understand my example. I wasn't talking about code conflicts which can be easily detected by the code hosting system; I was talking about *feature conflicts*. The feature developed by B would clash with the feature developed by A and tests would fail in master even though they pass on each individual branch. It's totally possible and it happens with a branching model like the one you propose. I never said I can make any organization adopt anything immediately. Pair programming and mob programming face a lot of resistance because of the way many companies normally work, which is absolutely antithetical to CI and CD. If an environment allows to adopt those techniques, the benefits are immediately visible.
    1
  151. Hummm... that “coordination in daily scrums” makes me curious. First because that’s not what daily scrums are for and secondly because it makes me suspect that there is some conversation along the lines of “you go first, I go next, etc...”, which means sequential work, which means defeating continuous integration. Three days can be a huge time if your team works at a very fast pace. There are always ways to make integration/acceptance testing faster.
    1
  152.  @aurelienrb  the benefit is that, in the way I suggest, you are doing proper Continuous Integration. As said many times, rebasing master daily doesn't solve any problem because 1) if no one has ever merged anything in the meantime, it's completely useless 2) if only big chunks of work are merged into master, rebasing will cause big merge conflicts anyway 3) if someone has significantly refactored parts of the code you have in your branch, they are completely invalidating your code 4) no one is receiving your changes on that branch for a very long time hence other huge merge conflicts will arise. I could continue. The approach to follow is continuous integration: work should be granularized and integrated into master multiple times a day. Do not ever think that conflicts are always easily resolvable: if you don't know anything about other people's changes, you're gonna mess up sooner or later. Do I consider merging stuff into master and then removing it a problem? Absolutely not. Master is a workbench just like every other branch. With feature toggles, you can do whatever you want.
    1
  153. In bocca al lupo, dottoressa!
    1
  154. Not sure what kind of point people are trying to make when they force six police officers to drag them to their car.
    1
  155. The squeaking pen is killing me...
    1
  156. >In real life you often have to undo days of work, refactor days of code, incorporate feedback from other stakeholders and so on. People keep mentioning this "real life" like they are the only ones living in the real world and people like Dave Farley come from Mars. Please appreciate the fact that we all belong to the same reality. It's just that we have different work experience. The way of working that Dave is advocating is used effectively by many companies, some of which very large, with extremely large projects, and a huge number of developers. >people will start using your unfinished code and start editing files you are working on. Long-lived feature branches only make things worse in that case. TBD is much better, especially when heavy refactoring is involved. Imagine what would happen if we work in the same team, I branch from master, you branch from master, and start refactoring a number of classes you are working on, maybe removing some code that you are changing. I finish and merge into master. At the moment you need to merge, you will end up in merge hell. It will be impossible for you to understand how to fix the merge conflicts cause you don't know my changes. You will need me to help out, which basically means having you redo the work of days on a completely changed codebase.
    1
  157. That's a non-sequitur. Continuously integrating code and releasing features are two different concepts. You can integrate your code multiple times a day even though your feature will be released in 3 months time. Code landing into master/main doesn't necessarily mean that the feature implemented by that code will be released to production in the hands of customers straight away. You can adopt feature toggles to hide any incomplete or non-yet-validated changes. If you can use feature branches, then you can use a single branch with feature toggles. It's exactly the same thing. In the former case, the separation of your features is physical; in the latter case it's logical.
    1
  158.  @ShroySha  Ah the good ol' "I am not gonna give you any evidence, look for it". Very solid argument dude :)
    1
  159. Wow... where do you work, in a rat cage? :D Mob programming works in environments that embrace mob programming :)
    1
  160.  @Thorax232  Jesus Christ... the way you guys trivialize valuable practices is incredible: "3 people chirping in my ear". It must be such a pleasure working with you.
    1
  161.  @cyrusol  It's fine. You can disagree. You will agree, however, on the fact that what is important for you might not be important for other teams. Git logs are there to track a chronological sequence of commits to a branch. That's it. The concept of "clean" associated to that list is always subjective. Many teams might not care at all about keeping that list clean. They might have a policy of not reverting any commits and just rolling forward. They might be inserting an id in each commit message that easily correlated all commits for a single feature. And so on. They just don't need any concept of "clean".
    1
  162. I totally disagree. Tests are indeed a way of documenting the code, but they have to be written the right way. Keep your test methods short, with just three phases: given/when/then or arrange/act/assert sections, and what the code does will be obvious. When reviewing someone else's code, the first place to go to is tests. When someone asks me about a certain behaviour of the system is correct, I go look at the tests, not the code, to see what it does. You write down intent by making it clear what the expectations are.
    1
  163.  @RFalhar  >I would be interested in seeing Allan talk about research on surrogacy, instead of using his personal opinion and experiences, which can easily be biased. Why? We all refer to our professional experience all the time. It's the data we have. When our data reflect the research on surrogacy, I don't see the problem.
    1
  164.  @RFalhar  Research around metrics and surrogacy prove him right.
    1
  165. ​ @tonytheprogrammer1716  >The abuse generally comes about due to some ignorance regarding what is the important underlying phenomena we are trying to observe. That's a trivialization of the problem. It's not just ignorance. Weaponization of metrics happens all the time in business, even in good faith. It's just a dangerous consequence of using a dangerous tool. Are metrics useful? Absolutely yes. Are they easily weaponizable? Absolutely yes. Are they weaponized all the time? Absolutely yes.
    1
  166. Automated tests.
    1
  167.  @silentwater79  The fact that someone else, other than the developer, has to test the code is not true in general. If you adopt a test-driven/behaviour-driven approach, that gives you a black-box perspective. The work of a human QA is not necessarily required (I know many large projects that don’t use humans for testing other than exploratory). In any case, no, even if a feature required human validation and that would take time, you could still merge your code into master and release it to production, as long as feature toggles were used to hide it. One thing is the ability to continuously integrate the developer’s code into a shared mainline multiple times a day, one thing is the validation of the features implemented for releasing to production. Two different concepts.
    1
  168.  @jeremykothe2847  I think that short-lived feature branches can be even worse than long-lived ones, in some environments. The shorter the life of your branch, the more frequent you need reviews, so reviewers in your team will be context-switching all the time. The obvious alternative is that they will take their time to review your changes, totally invalidating the short life of your branch and impeding your progress. The only feasible option is really getting people work together (pair/mob programming) and do continuous review. If you want to adopt trunk-based development, I suspect you'll need to carry out a lot of groundwork to shorten your feedback cycle. Having only nightly tests is not acceptable with tbd. At least you should have a suite of smoke tests that a dev can run before pushing their changes.
    1
  169.  @jeremykothe2847  >the only technical difference is where the tests run? The difference is Continuous Integration.
    1
  170.  @jeremykothe2847  your local 'master' branch is just a technicality dictated by git being a DVCS. The difference is that your local master is constantly sync-ed with the remote master by pushing your changes frequently during the day. The branch associated to a PR isn't.
    1
  171.  @jeremykothe2847  PR tests run only when you create the PR, the branch associated with the PR is not continuously kept in sync with master. Please read the basics about continuous integration.
    1
  172. Test coverage thresholds make little sense. Remember Goodhart's Law: "When a measure becomes a target, it ceases to be a good measure"
    1
  173. I think you'd be interested in this video by Jez Humble (who co-wrote Continuous Delivery with Dave Farley), who explains how they adopted continuous integration at HP for the firmware of their LaserJets: https://www.youtube.com/watch?v=mBUJ-fg4EKA&t=1395
    1
  174. >to be able to think through the problem steadily and come up with an accurate solution, especially for more complicated problems, and I don't think its possible to do this deep thinking whilst in a mob. Yes, it is possible, but it's a skill that needs to be learned and perfected. Problems must be solved collectively, not alone. The solution is always better when multiple brains share ideas/approaches. You can still spend some time in isolation, if you need, but check back with the team frequently. The risk with thinking alone for too long is that we don't find flaws in our reasoning early, and may go off a tangent.
    1
  175.  @donka86  my question is why set up that cannot work together due to different time zones?
    1
  176.  @donka86  Distributed teams are common but you were mentioning distributed teams *across multiple timezones*. Placing people from distant timezones in the same team is a recipe for disaster. distributed teams across multiple timezones are notoriously difficult to manage. I would never set up a team with someone in the US, someone else in UK and someone else in India, for example, a practice that I've seen in a few places. You can totally pair/mob program remotely, via the various tools available (Code With Me, LiveCode, etc...). If your work hours largely overlap those of your colleagues, you can pair program.
    1
  177. I’ve been applying that idea for a very long time now. It is a very natural thing to do once you have some experience. I tend never to mix behavioural changes to structural changes. If I noticed, for example, a typo, or I spot a function that needs implementation (not interface) refactoring, I do that in a following PR (to be done soon after the one with behavioural changes I’m working on). PRs, for me, must have a very limited scope.
    1
  178. Mob programming has been my favorite way of working for quite a long time now. Whenever I used it, we ended up being way more productive than working independently, with the nice side effect of sharing knowledge across the team, increasing confidence in answering questions about the system, increasing job satisfaction, reducing burnout (deadline was 5pm — no work after that time). I remember joining a team where 4 out of 5 people were new. There was only 1 person who'd been in the company for a few years, who knew the system well and could answer questions. He ended up spending most of his day assisting others. I proposed moving to a mob programming model. It started as an experiment but it became our standard way of working. For me, the crucial moment was when, jokingly, someone said, well "C. is the expert in our team!", to which C. smiled and replied "not anymore!!". Everybody had become an expert. I think there is an upper limit, though, and that's 4-5 people (which, to me, should be the size of a team). I'm aware, however, of a few contexts where large mobs worked really well. Austin Chadwick and Chirs Lucian (Mob Mentality Show, here on YouTube and LinkedIn) interviewed an engineer from Tesla some time ago, if you are interested.
    1
  179. There is a well-known phenomenon called "surrogation". Psychologists have been writing about it for years.
    1
  180.  @miletacekovic  >Of course, you can delay branch creation till bug is found in it, and create a branch from tag when the bug is found. But once branch is created to fix a bug, you need CI pipeline attached to it. It's not a CI pipeline, it's a build pipeline. It's different. CI means something specific: Continuous Integration. You don't do Continuous Integration on the releasae branches, you keep them for hotfixes. In general, however, keeping a release branch for every customer, assuming that you have hundreds of customers, is suicidal, a good recipe for disaster. You cannot really expect to have to hotfix a bug on hundreds of branches. You will need to make those customers converge into a new release at some point. >Verifying if a bug fix did not break anything on developer workstation is little scary for medium to large systems . What developer workstation? Who has ever talking about developer workstations? Developers' workstations are temporary workbenchs. CI is about integrating developers' work into a shared mainline multiple times a day. Tests run on the mainline.
    1
  181.  @miletacekovic  You are not doing continuous integration on the release branch. Therefore you cannot call the build for that release branch a "CI pipeline". You are fixing bugs on that release branch, you are not continuously integrating new development. That bug-fixing activity causes frustration among your developers, rest assured, given that they have to apply the same fixes in multiple places, with all the problems that that practice entails. If you have several bugs, discovered for multiple client's version, you need to multiply that bug-fixing activity for all those branches, increasing frustration and fear of mistakes. The idea that you can keep release branches open indefinitely is not a sustainable model. It doesn't really work anywhere. You will need, at some point, to make your release branch converge into master again or you are doomed to eternal sadness. Stop calling it "CI pipeline". CI happens ONLY on the shared mainline of development, nowhere else. You are talking about separate builds that happen on the CI server. It's not a "CI pipeline".
    1
  182.  @nzalex1  you are vaguely referring to "some situations where it might be better". There is no evidence from the industry that having multiple sources of truth is convenient at times. Multiple sources for truth cannot exist because they would only create confusion (it's ingrained in the concept of "source of truth" that thee should be only one). On the othe hand there is a lot of evidence from the industry that continuous integration/trunk-based development is beneficial to increase the throughput of software teams. I am not creating any "limitation". Feature branching is a practice incompatible with continuous integration. That's it.
    1
  183. Questi votano. E` triste.
    1
  184. Every developer working on a different part of the system is not a team. It's a group of individuals each working in their own silo.
    1
  185. ​ @Oliver Thane No, B would not be able to see any of A's changes because A has not merged any changes into master yet. The point of continuous integration is in that "continuous". If you and I branch from master today and keep working for the next three days on our branches, rebasing frequently for the next three days would bring no benefits to any of us. Not sure why we should resign with "it's just life" when there is a better way of working, which is actually much more practical and solves the integration problem?
    1
  186.  @INFOXlive  I’m amused by your comment 😄. The first principle in the Agile Manifesto states: “our highest priority is to satisfy our customers via early and continuous delivery of valuable software”. The fact that software must be delivered continuously is specifically stated in that foundational principle of Agile, so I don’t understand where you see the falsity in my statement. The Agile Manifesto contains a set of values and principles that foster agility: the ability to respond to change quickly. I was asking you a specific question: do you know a better way of working? That’s the opposite of being dogmatic. I’m all ears. I’m open to learning a better way from you. How do you think software should be engineered if not following the points that Dave is mentioning in this video? You say that they are meaningless but you offer no alternative. What do you think is an advisable way to engineer software so to meet targets more quickly, effectively and with higher quality standards?
    1
  187.  @DanielSanchez_dsanc89  mob programming.
    1
  188.  @thenewms5333  LOL :) What a bunch of bs. I never read so many logical fallacies in a single comment. Where do I start? First of all, I, as an engineer, am ALWAYS accountable for the quality of my team's deliverables. The idea that by doing pair programming your're not is just as ridiculous as the rest of drivel you've written. Now it's clear why you love the way you work so much: because you've made yourself indispensable, you love being an ivory tower, a huge bottleneck for the team, and cause a humongous bus factor for the company. You clearly enjoy being some sort of semi-god with the last word on the team's work. What happens if you're on holiday, you're sick, or you even die? Should the team find themselves in big trouble because you're not there? 20 PRs a day, LOL :D, yeah sure... counting 480 minutes in 8 hours of work, that means one PR every 24 minutes. You have no time to use the toilet, at that point, nevermind do any work. Again, what a bunch of bs! You may be convinced all you want that pair programming doesn't work or that the continuous review process it entails doesn't work, and you couldn't me more wrong. The proponents of XP prove you wrong, the everyday practice of software development in many places (Amazon, Google, Industrial Logic, Hunter Technologies, and dozens of other companies including the ones I've worked) prove you wrong. The mountain of data that have led to the book "Accelerate" prove you wrong. The State of DevOps reports proves you prove. And so much more. All resources that you are clealry going to ignore because they generate cognitive dissonance in you :) Pair programming works. Mob programming works. Continuous code reviews work. Senior engineers must sit and work with the rest of the team. Knowledge is spread by working together. Juniors learn by working WITH seniors, not by reading what seniors write in their comments. The comparisons you make with other fields of the industry are completely fallacious. It's software development, not auto mechanics, hardware or "consultants". Software is a beast that moves and behaves unlike many other human artefacts. Your problem is clear: you know very little about how software is developed, and angrily reject anything that dissonates with what you do. Well, good luck, your team and your company need it.
    1
  189.  @thenewms5333  LOL :) you are really clueless dude. I am not making fun of you, you are perfectly capable of making fun of yourself. Good luck, you need it!!
    1
  190.  @thenewms5333  a good CTO wouldn't need me to explain that. He would know that pair and mob programming are great practices. What he might not understand is why keep an arrogant "tech lead" in the team, who acts as a semigod "reviewing 20 PRs a day" (LOL!!) Stop trolling, dude, seriously, you are embarrassing yourself.
    1
  191. If your development team spends valuable time on unnecessary features, then you have a big work optimization problem.
    1
  192. The mistake is thinking that PRs are needed for code reviews. Code reviews can be done continuously. No need for PRs. PRs were never meant for durable product teams of colocated, trusted collaborators. They were meant for open source projects having lots of external, untrusted collaborators. Peer review == pull request, as Thoughtworks also says int their tech radar, is a false equivalence.
    1
  193. 1:17 another masculine scream
    1
  194. >The main flaw in this video is that it assumes that you have just one 'Production'. What do you mean? >Also, around 10 minutes it is said that the devs should push to remote master daily which is just crazy in any environment with a team Not crazy at all. With pair and mob programming, you get continuous reviews and can be sure that high-quality code is committed to remote master multiple times a day. Try it, it works.
    1
  195.  @alexanderzaytsev1265  so what happens when you have hundred customers? Do you create hundred branches? Each to be maintained in parallel? That's not a sustainable model. You don't have multiple sources of truth, you have one that you can configure in one way or the other for the various customers. Features can be exposed or hidden via toggles. Releases should be tagged, not have branches associated to them. No, pairs don't need a further validation. Working in pairs is a guarantee of code quality that doesn't need the validation of a third reviewer. Also because there would be no guarantee that a reviewer would be stricter with regard to rules, then the pair working together. Trust is an important value in a team. If you don't trust your team members, thinking that they might be doing something dodgy all the time, then you have big problems. No, pairs don't need PRs, because in a continuous integration fashion they would committing small batches of changes straight to master, not before validating them with tests.
    1
  196.  @alexanderzaytsev1265  the release branches you mention are for hotfixing, not continuous deployment. As I said, it is totally possible to keep feature segregated in a way to respect what your customer s accept or don't accept. If you have acceptance critieria for each of your customers, you can test continuously and make sure you don't break any existing contracts. No, PRs are not thee way you keep track of technical decisions. Indeed no one used them that way. For that, there are other documentation tools to use see ADR for example, or short design docs collecting feedback from architects, experts in an area, etc. Pairs should be autonomous and, by working together, they continuously review the coee. They don't need third parties to look at what they've done with little to no context. Trust is a very important principle.
    1
  197. PRs are NOT designed to be a documentation tool anyway. If you use them that way, you are using the wrong tool for the job. The industry of software development has by now discovered that working in small batches in immensely more fruitful than delivering big chunks of work and you cannot really expect to create a PR for each small batch. PRs are not meant to be used by a team of trusted collaborators. Rebasing master often into feature branches doesn’t bring any benefits: if two developers branch from master and work on their branches for days, they won’t be able to see each other’s changes for days. Rebasing master every day is completely useless and does not constitute Continuous Integration.
    1
  198. Again, quoting some experts here: "...we have to work in very small batches. This is antithetical to the way lots of developers like to work: sitting off on their own going down a coding rabbit hole for days before re-emerging. The elevation of "flow" (by which I mean individual flow, not lean/team flow, which is actually inhibited by this behavior.) [is much at fault here]. Trunk-based development is about putting the needs of the team above the needs of individual. The premise of CI and trunk-based development is that coding is fundamentally a social, team activity. This presents a challenge to the mythos of the developer-as-hero which is still pervasive in our industry." (Jez Humble) "Although designed to make it easier to accept contributions from untrusted people outside a team, many teams now use pull requests for people inside their own team. This practice has become so common that many people consider it a default, “best” practice. Some people assume there is no other way to make sure code is reviewed because they’ve never seen anything else." (Kief Morris) “Some organizations seem to think peer review equals pull request; they've taken the view that the only way to achieve a peer review of code is via a pull request. We've seen this approach create significant team bottlenecks as well as significantly degrade the quality of feedback as overloaded reviewers begin to simply reject requests. Although the argument could be made that this is one way to demonstrate code review "regulatory compliance" one of our clients was told this was invalid since there was no evidence the code was actually read by anyone prior to acceptance. Pull requests are only one way to manage the code review workflow; we urge people to consider other approaches, especially where there is a need to coach and pass on feedback carefully.” (ThoughtWorks)
    1
  199. The funny thing about pair programming detractors like you is that you guys keep wishing “good luck”, like this is a new idea that people came up overnight, or some sort of new fancy theory they are proposing. Pair programming is one of the pillars of XP, which is more than 30 years old and has been a standard practice in trunk-based development environments for many years now. I have used pair and mob programming approaches in many places, always received very well by the team. The benefits of working that way were immediate, both to the team and the company. Look, I understand that software development is hard and you have reached a certain equilibrium in your current place that you now consider a holy grail, but there has been a lot of research in the industry, a lot of evidence has been collected that certain ways of working are better than others and conducive to better quality, higher job satisfaction, happier customers. You want to read about it? Look at “Accelerate”, a good book written by the DORA guys. This agreeing to disagree is often a way of shutting eyes and ears to what’s out there that could really improve your way of working. Read “Continuous Delivery”, written by Dave. It’s an eye-opening gem.
    1
  200.  @alexanderzaytsev1265  >In teams I lead I would never allow it, the risk is too great and the benefit is … zero. Google trunk-based development or watch videos on YouTube explaining what that is, and you'll realise how wrong you are.
    1
  201. 3:09 that's basically me in GTA 5
    1
  202. [8:33] False dilemma fallacy: it is not either you are abrasive and insult people or take them by the hand, walk on eggs and soft-talk to them. We can still be honest, firm and direct in our feedback, at the same time keeping things respectful and constructive. Communication between humans is complicated and it takes one iota of brutality to destroy a perfectly valid message. Not recognising that and going straight with an "I don't care", is not a sign of intelligence.
    1
  203. >Did I totally misunderstand what you were saying or did you advocate to committing to main directly? Where does pull requests fit in your workflow? With pair programming and/or mob programming, you don't need Pull Requests. Pull Requests are not the best model to review code and can have pretty nasty effects on the team. With pp/mp, you get continuous code reviews, which is a much better way of reviewing code than a PR-based model at the end of a long development phase on a feature branch. >Let's forget PRs for a second (One of the foundations of quality). Wait. That "one of the foundations of quality" is highly debatable. The usage of PRs within a team of trusted collaborators is a distortion of the original meaning of PRs. They were meant for groups of untrusted collaborators working on open source projects (where the concept of team doesn't really make sense). Used as a quality control tool for a team of colocated, trusted engineers can be detrimental to the team, the company and - above all - the customer. Often engineers have to review very large PRs, from which it's hard, if not impossible, to get a clear idea of how a feature is shaping up. In many cases, reviewers are in a weird situation where they can either reject or reluctantly approve the changes. In many other situations, there is an obnoxious back and forth of comments that waste time, block the team, raise flamewars, and slow down development. In many cases, compromises will be reached ("let's leave it like that for now") that will have no other effect than increase the tech debt in the code base. It's about time to abandon PRs for a better model. This is what Kief Morris says: "Although designed to make it easier to accept contributions from untrusted people outside a team, many teams now use pull requests for people inside their own team. This practice has become so common that many people consider it a default, “best” practice. Some people assume there is no other way to make sure code is reviewed because they’ve never seen anything else." This is what Jez Humble says: "...we have to work in very small batches. This is antithetical to the way lots of developers like to work: sitting off on their own going down a coding rabbit hole for days before re-emerging. The elevation of "flow" (by which I mean individual flow, not lean/team flow, which is actually inhibited by this behavior.) [is much at fault here]. Trunk-based development is about putting the needs of the team above the needs of individual. The premise of CI and trunk-based development is that coding is fundamentally a social, team activity. This presents a challenge to the mythos of the developer-as-hero which is still pervasive in our industry." This is what the guys from ThoughtWorks say: "Some organizations seem to think peer review equals pull request; they've taken the view that the only way to achieve a peer review of code is via a pull request. We've seen this approach create significant team bottlenecks as well as significantly degrade the quality of feedback as overloaded reviewers begin to simply reject requests. Although the argument could be made that this is one way to demonstrate code review "regulatory compliance" one of our clients was told this was invalid since there was no evidence the code was actually read by anyone prior to acceptance. Pull requests are only one way to manage the code review workflow; we urge people to consider other approaches, especially where there is a need to coach and pass on feedback carefully." There are much better ways to review code. >IMO there are still a lot of developers who can't define a workable unit in to a single commit. They have to answer these questions 1. Does it build? 2. Does it run? 3. Does it pass unit tests? Even if that is the case if it's not shippable to production as is they need to put it behind a feature flag. This is a lot of overhead to repeat for every single commit. No, it's not. You don't have to create a feature flag for every commit. A feature flag can be seen as a logical feature branch: you create it once, at the start, you remove it once the feature is complete. Each small batch of work is validated (build/test/run) before being pushed to master: 1. TDD you change 2. Build/validate 3. Push it 4. Goto 1 >It just means you create a branch off main and create a PR into main when you're ready. That is not CI. That's feature branching, which is antithetical to CI (Dave has made specific videos on that too). Continuous Integration is defined as: "a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early. By integrating regularly, you can detect errors quickly, and locate them more easily." (ThoughtWorks) >If your branch lasts more than a day then you reverse integrate main into it every day or multiple time a day. You go slow to go fast. Merging master into your branch doesn't add any value if no developer has merged their changes into master yet. If you and I create our own branches and work independently for days on our features, none of us will merge stuff into master for days; we will both do at the end of development on our feature branch, so merging master daily brings no benefit. Moreover, if I am massively refactoring the code and you are modifying part of that code, you'll end up in a huge merge hell: you'll need to reapply your changes from scratch, wasting days of work. With trunk-based development (e.g. CI), instead, you can refactor freely, knowing that any stepping on others' toes will be detected and fixed almost instantaneously. >I totally get your argument but it assumes great levels of discipline and without the pull request process there is an increased likelihood of unfit code going into main. See above: that's wrong.
    1
  204. If changes are not finished yet, you can use feature toggles to hide them. Feature toggles offer the same benefit of branches, only it's a logical segregation, not physical. Code with bugs should not be checked in, as bugs are supposed to be captured by tests and tests need to be green for each commit. The code review process, with pair or mob programming is continuous, you don't need PR. You go with continuously reviewed code and merge it into main multiple times a day in small batches.
    1
  205. Then don't have a ridiculous number of feature toggles. Feature toggles offer exactly the same segregation of features that feature branches do. Only, it's logical rather than physical. Feature toggles are contingent. You develop something and until finished is behind a feature toggle. I develop something and until finished is behind a feature toggle. You finish and remove the toggle. I finish and remove the toggle. We move on to other tasks. Why would we ever have a "ridiculous number of feature toggles"? What kind of assurance are you looking for?
    1
  206. >For example Feature branches allow some form of distribution of knowledge and quality control through a Pull Request review. You can achieve a higher level of distribution of knowledge and real quality control by having people work together. Pull requests do not normally guarantee quality control. There are fundamentally 2 scenarios with pull requests: 1) a very large PR is created after days of isolated development on a feature branch, containing a lot of files suddenly presented to the reviewer. Having to statically analyse many different files doesn't give an organic view of how a feature is shaping up. A reviewer might either reject the PR or approve with a "LGTM". 2) a series of small PRs are created at the end of each increment of development, which also create a problem for the reviewer, who now needs to mentally keep up with granular PRs coming his/her way, trying to imagine how the feature is shaping up. >How can we achieve that when we aren't branching, what are alternatives to that team process. Adopt pair and mob programming and you'll get continuous code review. >Also, how do you support multiple static and/or ephemeral environments in this case, as multiple branches can easily map to these environments. Adopt feature toggles and activate the features in specific environments for testing.
    1