Programming

We use them at Meta. It's easier to interact with other parts of the codebase, but it doesn't play well with libraries so you end up redoing a lot of stuff in-house.

I would only recommend a monorepo if you're a company with at least 5,000+ engineers and can dedicate significant time to internal infra.

They work great when you have many teams working alongside each other within the same product.

It helps immensely with having consistent quality, structure, shared code, review practices, CI/CD....etc

The downside is that you essentially need an entire platform engineering team just to set up and maintain the monorepo, tooling, custom scripts, custom workflows....etc that support all the additional needs a monorepo and it's users have. Something that would never be a problem on a single repository like the list of pull requests maybe something that needs custom processes and workflows for in a monorepo due to the volume of changes.

(Ofc small mono repos don't require you to have a full team doing maintenance and platform engineering. But often you'll still find yourself dedicating an entire FTE worth of time towards it)

It's similar to microservices in that monorepo is a solution to scaling an organizational problem, not a solution to scaling a technology problem. It will create new problems that you have to solve that you would not have had to solve before. And that solution requires additional work to be effective and ergonomic. If those ergonomic and consistency issues aren't being solved then it will just devolve over time into a mess.

Most companies will never have a monorepo at the level of these bigger companies. So I personally don't think most people need to worry about the limitations of github/lab as platforms.

However if you happen to be having those kinds of issues, I think looking at what the big companies are doing and/or starting to split things up makes sense.

There's also alternatives with custom ci jobs within non GitHub/lab within the git universe that may help out with those sorts of operations. I know actions still feel very beta in some toolsets so it may be easier/more useful to run your own arch. I've been enjoying forgeo/gitea for example, but it's not like you can't do the same with girlab runners or GitHub enterprise. Depends on use case.

I have no experience using them across an entire company, let alone team. So far, it always seemed good enough to keep just each project in a repo. But yeah, for larger projects consisting out of multiple applications, I would not want to work without a monorepo for that.

Many of the benefits from the video still apply, mainly the consistency in code changes was always useful. You can check out any commit and you've got the exact state how everything worked together at the time. No wrangling different versions, no inconsistencies between APIs.
In our build process, we include the Git commit into the applications to have it logged on start-up, so when we get an error report+logs, we can always easily look at the respective code.

But it does depend on your build tooling, if this works well. JVM languages with e.g. Gradle's multi-project builds are great. Rust's workspaces are a treat. Python is fucking atrocious with everything we've tried (pipenv, poetry, lots of custom scripts+symlinks).

I've been a big fan of monorepos because it leads to more consistent style and coding across the whole company. It makes the code more transparent so you can see what's going on with the rest of the company, too, which helps reduce code islands and duplicated work. It enables me to build everything from source, which helps catch bugs that would only show up in prod due to version drift. It also means that I can do massive refactorings across the company without breaking anything.

That said, tooling is slowly improving for decentralized repos, so some of these may be doable on git now/soon.

We use a mono repo for a new cloud based solution. So far it's been really great.

The shared projects are all in one place so we don't have to kick things out to a package manager just to pull them back in.

We use filters in azure pipelines so things only get built if they or dependent projects get changed.

It makes big changes that span multiple projects effortless to implement.

Also running a local deployment is as easy as hitting run in the ide.

So far no problems at all.