I’ve heard it thrown around in professional circles and how everybody’s doing it wrong, so… who actually does use it?
For smaller teams
“scaled” trunk based development
- wewbull ( @wewbull@feddit.uk ) English26•4 months ago
Second diagram, yes absolutely.
Short lived (1-2 day) branches, and a strong CI systems to catch regressions.
Be warned, the strength in the CI lies in its capacity to detect when some functionality that previously worked doesn’t work anymore. So, the flow must be green always, and it must evolve as the features evolve. Without good CI you’re destined for failure.
- Ismay ( @Ismay@programming.dev ) 16•5 months ago
I do, on a 900+ developer mono repo. Works like a charm.
We just have a CD that allows to deliver each project each micro service individually.
- luciole (he/him) ( @luciole@beehaw.org ) 8•5 months ago
Holy crap that’s a lot of devs 😳
- Ismay ( @Ismay@programming.dev ) 5•5 months ago
Yeah, the biggest problem is keeping up to date.
That’s where the mono repo really shines. We have a folder for common stuff that everyone depends upon. A modification is automatically applied/compatible with every micro service. Really streamline the lib updates problem ^^
Out of curiosity, how long are CI and CD runs? And are there any particularities in the way of working for example every PR/MR is created by pair programmers, or the use of josh to cut down on time to clone, stuff like that.
- AggressivelyPassive ( @agressivelyPassive@feddit.de ) 3•5 months ago
If cloning a repo is an issue, you’re using CI wrong. --shallow has it’s purpose.
Anyway, in my project a complete CI run including local integration tests takes about an hour. We could cut that down by running things in parallel, but we never bothered to add more runners.
I would say, if your tests hold you back, you might want to reconsider testing. Staged testing is an option, or just reevaluate whether you really need all those test cases. Many integration tests are not really testing that much, because 95% of them overlap.
- Ismay ( @Ismay@programming.dev ) 1•5 months ago
No problem for the cloning.
A CI run is around 8 mins. We just use bazel to determine what to run and to keep cache of unchanged tests.
- johnydoe666 ( @johnydoe666@lemmy.dbzer0.com ) 10•5 months ago
I’ve been doing this for the past 10 years or so. When I joined my current company a few years ago, it was one of the first things I pushed for. It made cycle times go down drastically and value is being delivered to end users at a much higher rate now.
With enough tests and automation, there is almost no reason not do on the web. On embedded or mobile platforms this might be a bit more difficult, although not entirely impossible.
The use of feature toggles also greatly enhanced our trust in being able to turn a feature off again if it turned out to be faulty somehow. Although we usually opt for patching bugs, it gives the business as a whole more confidence.
- jjjalljs ( @jjjalljs@ttrpg.network ) 9•5 months ago
Here there’s main. You branch off. Do your work. Make a PR to main. Build passes and someone approves, merge to main. Production release is done by tagging main.
The branches are short lived because the units of work we select are small. You have like one pr for an endpoint. You don’t wait until the entire feature with 20 endpoints is ready to merge.
Seems to work fine. I think this is different than trunk based development but honestly I’m not sure I understand trunk.
Seems to work fine. I think this is different than trunk based development but honestly I’m not sure I understand trunk.
Same. But it feels like you’re doing it.
- Martin ( @mundane@feddit.nu ) 1•4 months ago
This is enough for most projects.
- luciole (he/him) ( @luciole@beehaw.org ) 8•5 months ago
Team of three. We do the feature branches, pull requests and code reviews. With the right culture, it keeps devs informed about the various projects and gives a nice space to discuss about the practice.
EDIT: we do automated linting and formatting checks too. Keeps things coherent.
- BatmanAoD ( @BatmanAoD@programming.dev ) 6•5 months ago
I haven’t worked on any teams where all members committed “every 24 hours”, and there have always been some branches that live longer than we’d like (usually just unfinished work that got deprioritized but still kept as an eventual “todo”), but most teams I’ve worked on have indeed followed the basic pattern of only one long-lived branch, reviews and CI required prior to merge, and all feature-branches being short-lived.
- ____ ( @____@infosec.pub ) 7•5 months ago
A hard timeline on commit strikes me as less than ideal.
People are people. They have issues, they screw up, but they still write good code.
Seems like a brutal metric that encourages minimal commits without real change.
- BatmanAoD ( @BatmanAoD@programming.dev ) 1•5 months ago
Yeah, agreed.
- KindaABigDyl ( @KindaABigDyl@programming.dev ) 6•5 months ago
Yes. We use SVN. I hate it. I’m trying to build a case to switch to git. We’re a small team, but a growing team
- MajorHavoc ( @MajorHavoc@programming.dev ) 11•5 months ago
Welcome time traveler. If you’re able to return to your own timeline, buy some Apple stock.
/joking
But I hope your team does migrate. SVN is pretty bad, compared to git.
- CrypticCoffee ( @CrypticCoffee@lemmy.ml ) 4•5 months ago
Do you really need to make a case? Does your company not trust devs? Is there people leading that have no idea about technology? SVN is dead. Many devs won’t touch it. It’s best way to say to new candidates your company is backwards. Many would refuse to work in a company that uses a version control system that has been dead 7 years.
- KindaABigDyl ( @KindaABigDyl@programming.dev ) 2•5 months ago
It’s effort to switch, and we don’t benefit from having separate copies of the repo bc we’re so small. No one steps on eachother’s toes, so distributed version control isn’t necessary.
Now, the fact that most devs know git and SVN is dead is not lost on our CTO, but putting the effort to switch over doesn’t provide direct value to the customer, so I have to make the case that switching to git would do enough from a productivity and maintenance standard to effect customers.
- shastaxc ( @shasta@lemm.ee ) 1•5 months ago
But just productivity and maintenance but if your devs start to leave or retire, you’re not gonna get the best quality replacements for them if you’re using outdated tech. No one wants to learn new skills that aren’t going to help with their career growth.
- KindaABigDyl ( @KindaABigDyl@programming.dev ) 1•5 months ago
I’m a relatively new hire and we just hired another person 2 weeks ago
- 0x0 ( @0x0@programming.dev ) 4•5 months ago
Team of one here tends to work on master only for very small stuff.
There’s a branch for the next release which will get merged once everything’s done. Occasionally there are smaller branches that fork off of the release branch and get merged back.
Meanwhile master is, most of the time, an old copy of the new release branch so merging goes without issue. Unless there’s a problem in prod, then it gets fixed in master and backported to the feature branch.
I should use feature toggles more (usually
#ifdef
, sometimesif (config_Flag)
), occasionally a big feature creeps in and i know management will change it at least 3 times and 2-3 new releases will come out in between… - lorty ( @lorty@lemmy.ml ) 4•5 months ago
This actually seems like git flow, but easier while achieving the same objectives.
- RecluseRamble ( @RecluseRamble@lemmy.dbzer0.com ) 3•5 months ago
Worked with both, both worked fine.
Different size companies, right?
- RecluseRamble ( @RecluseRamble@lemmy.dbzer0.com ) 1•5 months ago
Basically lower and upper end of sizes, yes. Team sizes too.
- walter_wiggles ( @walter_wiggles@lemmy.nz ) 2•5 months ago
Not saying anything about good or bad, but trunk-based development doesn’t work when the business requires you to have multiple releases under development concurrently.
- CubitOom ( @CubitOom@infosec.pub ) English2•5 months ago
In TBD, it’s not a “release” until its production ready. The methodology and philosophy doesn’t prevent you from developing multiple feature branches at once or even deploying a work in progress feature branch to a dev environment.
All TBD requires in that case is once the feature branch is production ready, it’s merged to the trunk. You may need to add a feature toggle if there are multiple release like for different architectures. And you also might benefit from using git tags and deploying to production from a git tag instead of the most recent commit on a branch.
Exactly what you need to do is going to depend on the project’s exact needs but TBD is totally possible in that example.
- wewbull ( @wewbull@feddit.uk ) English2•5 months ago
I don’t think anything works in that situation.
- MajorHavoc ( @MajorHavoc@programming.dev ) 2•5 months ago
Scaled trunk based all year long, every year, every team.
Life is too short to tolerate long-lived branches.
- Lmaydev ( @Lmaydev@programming.dev ) 2•5 months ago
Scaled absolutely. Works really well. We have a pr ci pipeline. And cd set up on the trunk. Everything is PRed before being merged to the trunk.
- lars ( @lars@programming.dev ) 1•5 months ago
We don’t have release branches, the commit is just tagged as being currently deployed in production.
People merge their feature branches to master during working hours (by merging CI validated PRs) and release when they get a chance. Normally do about 10-20 releases per day.
- Kissaki ( @Kissaki@programming.dev ) English1•5 months ago
I guess we do scaled trunk development, if you want to call it that. We do allow direct commits, for trivial or safe stuff where reviews would be more noise and hindrance than value. (Code formatting etc.)
We only have one current release version though. (And at times a current test version that deviates from it.)
If there’s a need to create a patch release for a tagged version when the trunk proceeded forward with something that shall not be included, I create only a temporary branch from the earlier tagged commit to tag (=create) that patch release.
What are the release branches supposed to be in your graphs? It says developers don’t commit. Then who does?
Those aren’t my graphs, there are from the link in the post. I’ve only once worked with release branches and it was a nightmare.