#Update git submodule to latest commit update
#Update git submodule to latest commit software
#Update git submodule to latest commit code

Let’s say we need a little “timezone converter” JavaScript library: $ git submodule add

#Update git submodule to latest commit code

Now we’re ready to pump some third-party code into our project - but in an orderly fashion, using submodules. Before we go get any code, it makes sense to create a separate folder where things like these can have a home: $ mkdir lib Let’s take the classic example and say we’d like to add a third-party library to our project. Maybe you just want to share your own code between two projects - a situation where submodules might offer the simplest possible workflow. Not every piece of code might be available over a package manager.Submodules, on the other hand, always work the same. Especially if you’re working with multiple technologies, each one might have its own package manager with its own set of rules and commands. Submodules provide a consistent, reliable interface - no matter what language or framework you’re using.However, you could argue that Git’s submodule architecture comes with a couple of advantages: You could also use one of the various “package manager” systems that many modern languages and frameworks provide. Luckily, Git’s submodule concept was made for exactly these situations.īut of course, submodules aren’t the only available solution for this kind of problem. And it’s certainly true for managing third-party code in your own projects.

#Update git submodule to latest commit software

The general rule in software development to “keep separate things separate” exists for a reason.

#Update git submodule to latest commit update

Whenever you need to update the library code (because its maintainer delivered a great new feature or fixed a nasty bug) you again have to download, copy, and paste.

The line between your own project and that of someone else (the library) starts to get blurry.

By brute force copying third-party code into your project, you’re effectively mixing multiple projects into one.

While certainly quick, this approach is definitely dirty for a couple of reasons:

When you need to include third-party code (such as an open-source library) you can of course go the easy way: just download the code from GitHub and dump it somewhere into your project. gitmodules file.To make clear why Git’s submodules are indeed an invaluable structure, let’s look at a case without submodules. If i want to track a particular version of submodules, I'll simply mention that in the. And I don't see it breaking any git principles. I don't want to argue, but this is our use case. If they do, for some really good reason, then all the dependent repos are supposed to update to that API before they update their own master/main next time. Now, the developers of those modules & libraries are not supposed to break the API. Your argument of compile time errors is invalid, since merge-to-master will not happen with compile errors. I'm using submodules, to refactor out common modules and libraries to be used in multiple projects (repos). And you are supposed to fix all compile time errors, since main is supposed to be the most stable, latest version of the codebase. Git is used to track software versions, yes.īut when u merge into master/main, you are supposed to fix all the merge conflicts, which might have happened due to API changes by other developers.