PBS_2024_12_07
An audio podcast where Bart Busschots is teaching the audience to program. Associated tutorial shownotes are available at https://pbs.bartificer.net.
Automatic Shownotes
Chapters
Welcome and Episode Setup
Behind the Scenes of Episode Creation
Understanding Git Submodules
Exploring Scenarios for Git Usage
Enhancing App Functionality
Branching Policy Changes
Implementing New Branches
Brand Design Overhaul
Developer's Integration Process
Merging Changes into Main
Troubleshooting Submodule Changes
Finalizing Updates and Push
Conclusion and Next Episode Teaser
Long Summary
In this installment of Programming by Stealth, recorded on December 7th, 2024, I, Alison Sheridan, delve into the intricate workings of Git submodules with my co-host Bart Bouchats. In this comprehensive session, we wrap up our three-part exploration of handling Git repositories within repositories, providing a deep understanding that is equally theoretical and practical.
We begin by reflecting on the extensive preparation that Bart undertook to design this episode. From concept creation to the development of various roles within a fictional company we've been using as a model, Bart invests considerable time in crafting scenarios that not only illustrate the lessons but also engage our audience in a meaningful way. I'm constantly impressed by his dedication, reminding listeners of the hours spent rewriting and refining this educational content.
The episode continues with an in-depth discussion on Git submodules, building on previous lessons by introducing real-world scenarios. We first tackle the scenario where an app developer identifies a need to enhance their application's brand elements. By exploring how to creatively modify a submodule while ensuring that the overarching project remains intact, we demonstrate the benefit of structured collaboration in Git. Bart meticulously guides us through fetching updates, using commands, and ensuring that our changes are properly committed and managed within the hierarchical structure of our submodules.
Transitioning to another scenario, we simulate a company rebranding effort, highlighting the importance of maintaining functionality while promoting aesthetic evolution. This leads us to address corporate branching policies and how to implement them in a structured and non-disruptive manner. We discuss the practical implications of having multiple versions of a brand exist concurrently within codebases and how developers can thinly slice their workflows to accommodate such changes. The depth of this topic reveals not just technical knowledge but also strategic thinking essential in software development.
As we navigate these scenarios, the discussion becomes particularly rich when we start to explore how branching and merging work in conjunction with submodules. Through straightforward examples, I ask clarifying questions that illuminate complex interactions — for instance, the repercussions of checking out branches without updating relevant submodules. This is critical, as it underscores the necessity of synchronizing the state of submodules with respect to their parent repositories.
Towards the end of the episode, we provide a summary of essential Git commands that have emerged throughout the discussion, equipping our audience with a practical toolkit. These commands include `git submodule init`, `git submodule update`, and `git checkout --recursive`, all of which play crucial roles in managing submodules efficiently.
This segment not only reinforces the learning objectives but accentuates the real-world applicability of these concepts, leaving our listeners with a comprehensive framework for navigating their own coding environments. As we conclude, I express my gratitude for Bart’s guidance and the depth of knowledge shared, setting the stage for our next exploration into Static Site Generators, promising a shift that will excite our coding landscape even further.
We begin by reflecting on the extensive preparation that Bart undertook to design this episode. From concept creation to the development of various roles within a fictional company we've been using as a model, Bart invests considerable time in crafting scenarios that not only illustrate the lessons but also engage our audience in a meaningful way. I'm constantly impressed by his dedication, reminding listeners of the hours spent rewriting and refining this educational content.
The episode continues with an in-depth discussion on Git submodules, building on previous lessons by introducing real-world scenarios. We first tackle the scenario where an app developer identifies a need to enhance their application's brand elements. By exploring how to creatively modify a submodule while ensuring that the overarching project remains intact, we demonstrate the benefit of structured collaboration in Git. Bart meticulously guides us through fetching updates, using commands, and ensuring that our changes are properly committed and managed within the hierarchical structure of our submodules.
Transitioning to another scenario, we simulate a company rebranding effort, highlighting the importance of maintaining functionality while promoting aesthetic evolution. This leads us to address corporate branching policies and how to implement them in a structured and non-disruptive manner. We discuss the practical implications of having multiple versions of a brand exist concurrently within codebases and how developers can thinly slice their workflows to accommodate such changes. The depth of this topic reveals not just technical knowledge but also strategic thinking essential in software development.
As we navigate these scenarios, the discussion becomes particularly rich when we start to explore how branching and merging work in conjunction with submodules. Through straightforward examples, I ask clarifying questions that illuminate complex interactions — for instance, the repercussions of checking out branches without updating relevant submodules. This is critical, as it underscores the necessity of synchronizing the state of submodules with respect to their parent repositories.
Towards the end of the episode, we provide a summary of essential Git commands that have emerged throughout the discussion, equipping our audience with a practical toolkit. These commands include `git submodule init`, `git submodule update`, and `git checkout --recursive`, all of which play crucial roles in managing submodules efficiently.
This segment not only reinforces the learning objectives but accentuates the real-world applicability of these concepts, leaving our listeners with a comprehensive framework for navigating their own coding environments. As we conclude, I express my gratitude for Bart’s guidance and the depth of knowledge shared, setting the stage for our next exploration into Static Site Generators, promising a shift that will excite our coding landscape even further.
Brief Summary
In this episode of Programming by Stealth, I, Alison Sheridan, along with my co-host Bart Bouchats, conclude our three-part series on Git submodules. We discuss Bart's intricate preparations that included creating fictional scenarios to enhance our explanations. With practical examples, we explore the nuances of modifying submodules in the context of application branding and corporate rebranding efforts, highlighting important strategies for maintaining project integrity during these processes.
As we tackle complex topics like branching and merging in submodules, I pose questions to clarify their interactions, emphasizing the importance of synchronization with parent repositories. We also provide a summary of essential Git commands, equipping listeners with practical tools to manage submodules effectively. This comprehensive session reinforces the real-world implications of our discussion and prepares the foundation for our upcoming exploration into Static Site Generators.
As we tackle complex topics like branching and merging in submodules, I pose questions to clarify their interactions, emphasizing the importance of synchronization with parent repositories. We also provide a summary of essential Git commands, equipping listeners with practical tools to manage submodules effectively. This comprehensive session reinforces the real-world implications of our discussion and prepares the foundation for our upcoming exploration into Static Site Generators.
Tags
Git
submodules
programming
Alison Sheridan
Bart Bouchats
application branding
corporate rebranding
project integrity
branching
merging
static site generators
Transcript
[0:00]Music
[0:07]Well, it's that time of the week again. It's time for Programming by Stealth, and this is installment 174, recorded December 7th, 2024, and I'm your host, Alison Sheridan, and of course, I'm joined by your wonderful co-host, Bart Bouchats. How are you doing today, Bart?
[0:20]
Welcome and Episode Setup
[0:21]I'm doing fine. If this is December 7th, is this the podcast that will live in infamy?
[0:27]Oh, I hope not. I hope not. Well, before we get started, I'm going to take over the show because I want to describe and hopefully help you appreciate what it takes for Bart to put together an episode like what you're going to hear today. The first thing he's got to do, of course, is figure out, you know, think up, guess what he's going to teach. What should I be teaching this week? Then in this case, he invents this fictional corporation that we've been following for the last couple of episodes, but then he has to dream up the different roles of the players in all of these different scenarios. I mean, we're going to go through two more scenarios than we did last time. So he's got to come up with all these different roles and he's got to map out the scenarios that will illustrate the things he want to teach. Then, you know what he does? He writes it and then he rewrites it and then he rewrites it until he's clear. And this part takes literally hours. I'm talking about the rewrites takes hours. And if he's super lucky, Allison is right ahead and given him tons of questions to help him rewrite it yet again. So um i appreciate the amount of work he goes i was just thinking about this when i was done reading going oh my gosh this took me two hours to read if it's uh how much work it must have been to put this together and think it up bart i appreciate you oh
[1:35]Thank you and if the listeners want to look under the hood because of the magic of gear they can see all the versions.
[1:45]Yeah that's a good point The scrollbar is way tiny on that list.
[1:50]Yeah.
[1:51]
Behind the Scenes of Episode Creation
[1:51]All right. Well, this is a meaty one, and we did a lot of faffing about before we got started, so we should probably get stuck in.
[1:58]
Understanding Git Submodules
[1:58]Indeed. So this is part three of three of our exploration of Git modules, sorry, Git repos inside Git repos, which Git calls Git submodules. So, in the first time, we listened to some pure theory motivations, why we care, why would we want to do this strange turtles all the way down thing. And then we looked at how to do the basics of the git module command. So how can we consume other repositories within our repositories, a little subfolder where we pull in someone else's stuff. And that's half of what Git does, right? You use Git to get open source projects, you use Git to get other stuff. But most of the time, we go the other way too, right? We push as well as call. We haven't done that yet with submodules. The other thing we know how to do is branch, branch, branch, branch, branch, right? There's often many whip branches on our show notes. So in the real world, that's what happens. So what happens with submodules when we branch? And we're going to learn that today. That is literally the two pieces left here for our submodules. So that's what we're going to do.
[3:21]All right.
[3:23]A few reminders, quite a few reminders. So we are playing in a simulation, our pretend company, and we're representing a whole bunch of people's PCs and a pretend server with folders. So our URLs are file paths, whereas in the real world, it would be https colon slash slan or ssh colon slash hash. So we hit into a security default, which says if a git command causes a git command, that second git command can't use a file URL, but we are. So we have to tell it, no, no, Mr. Git, we're fine with it. We mean you to do this with minus C for configuration, protocol.file that allow equals always, and that'll just work. We have to do that, but you don't have to do that normally.
[4:18]Right, right.
[4:21]And the other little reminder then is our little pretend scenario I dreamt up. So we are PBS Core. And Alison gives me credit for dreaming this up, right? But the naming I'm not so good at, right? I don't get marks for that.
[4:35]I like it. I like it.
[4:36]Okay. So when we left off, we had an imagined Git server with our little company that makes web apps. And that Git server has three repositories. PBS Core Brand, which is the company's unified style. PBS Core App 1, which is the company's first web app. And that links to the brand, which is the PBS Core brand repository using a submodule. And also PBS Core App 2, which does the same thing. So it has a folder named Brand that is a submodule that connects to the brand. So if you want to play along you can download the zip file extract the zip file change into that folder and then to get all this set up run the initialization script which has gotten quite long it's quite long this time so oh i can't hear you alison i.
[5:33]Should have added that to the list of things that you had to do is you had to write these scripts in order to cause the this and i bet you had to test it
[5:39]Repeatedly because it didn't work first time, do you know what takes most time sometimes me playing with the silly pretend web app because i end up stuck on google fonts for four hours looking for the perfect font.
[5:58]Okay that i i'm sorry to interrupt the show and i know this is going to run long but i did the same thing. I have not worked on my podcast because I was busy trying to figure out how to color in the glasses on the little Santa icon that I'd chosen to put on my Christmas card labels. Okay? So I was like in Affinity Photo and Affinity Designer and trying to find the right tool to paint in to make them dark sunglasses. So when you get your Christmas card, Bart, I hope you appreciate those sunglasses.
[6:28]I will. I'll pay extra close attention to, Okay, so what this big script is going to do is it's going to make our four folders. So remote-repos is pretending to be the Git server. PC-app1-dev is pretending to be the developer of app1. PC-app2-dev pretending to be developer of app2. And PC-brand-designer pretending the PC for the brand designer.
[6:52]
Exploring Scenarios for Git Usage
[6:53]Then it's taking the backups of all of our Git repositories where we left them last time, which are in bundle files and shoving those onto the pretend server as real git repositories and then it clones all of those newly created pretend git repositories on the server into the pretend pcs so we now have everything basically where we left it okay all right, so we have two scenarios so scenario number one is number four sorry that's bad naming um because.
[7:27]We did one two three we're on scenario four now
[7:30]Precisely so app developer two has decided that the brand is insufficient app two has run into an issue where the brand doesn't have enough styling choices so app developer two is brave enough to tell the designers that i can improve your brand.
[7:54]When I saw this section, I said to Bart, I said, I can't believe the app developer too is going to deign to touch the brand design. They're getting so spanked when she does that, it's going to be a big mess. But as we talked about, the brand people, they can just refuse the commit, or they can say, huh, that's actually kind of good. I think I'll accept that.
[8:15]Or second-guess it a bit, tweak it a little and then let little people use it. Okay, so if we go in and we open app 2 in your favorite browser, index.html, so change into pc app2dev pc core dash app 2, and then open index.html. So the problem to be solved is that the numbers aren't very clear. It's showing the seconds to Christmas, and we've had some feedback from our pretend users to say, ah, the number doesn't stand out. So how do we make it stand out? So the first thing we're going to do as a developer is try not to change the brand. What we're going to do is make the paragraph bigger. So this is using Bootstrap 5. So we're going to give it the class Display-3, which makes third biggest display heading. And, you know, that looks a little better. So to save you typing, I've made a copy of the whole file, which you can copy over index.html. And the command is in the show notes.
[9:25]Right.
[9:26]So it's bigger now.
[9:28]So now if we refresh it, so we refresh our browser, we can see these fancy new changes.
[9:34]Wow, it's bigger. It's not right yet.
[9:38]So the seconds to Christmas is what we're looking at for everybody who's following along. Okay.
[9:43]You'll see it grow, but the font is still a lovely font for text, but it's not a particularly digity font. Like usually something where digits, they're nicer defined digits. So we want to improve that. And as it happens, there's already a class on that paragraph called numeric, but there's no CSS to make that mean something. So developer could put that CSS in themselves in their own app, but surely other apps need numbers. So this should be centralized and consistent across all apps so it should go in the brunt great let's try that.
[10:25]In a way app developer 2 is doing a good thing to say look I think this doesn't look as good as it could but I don't want to just do it on my side I think it should be wherever we have this exactly
[10:36]So CD into the sub-module, so CD brand. We do a git fetch and a git status, because we want to make sure we're in a good place here, right? I've told you the init script has done everything, but you're the developer, it's your PC, you're not sure the brand people could have done lots of work while we were talking here, right? So git fetch, git status. Well, it's half good news. Nothing to commit working tree clean. Okay, we're ready to go. but it says head detached. Hmm. It sounds a bit fatal.
[11:12]I hate that. I always panic when I see it because I reread the link that you put in the show notes to remind us, and hopefully we can talk about it for just a second, but I can't wrap my head around what causes it, how I end up in that situation.
[11:27]So you can say git checkout and specify an exact commit, and then it will pull that commit as the currently working thing and if that's the head well no there's no head because the head is the top of a branch when you've checked out a commit rather than a branch there's no concept of a head oh.
[11:50]Oh okay okay
[11:54]So if you're in git kraken and you double click a commit halfway down the tree you're going to have a detached head okay.
[12:02]Okay i get i get it now yeah no that makes sense so so a branch is is has a head but a commit doesn't have a head
[12:11]Yeah commit is a place and to make a new commit it has to go at the head of something which is your current branch but if you're not at the head of a branch a commit can't go anywhere so you can't make changes soon.
[12:25]Because there's all those other ones after it that would affect, and that's what branching's for.
[12:31]Bing, bing, bing. Exactly. So if you want to start halfway down the tree, you make a new branch there, then you have a head, the head of your new branch, and you can commit away. But until you make a new branch, you can't.
[12:44]Right. So I get that now. But all we did was look at the brand and fetch it. Right. We didn't check out a commit, did we?
[12:53]We didn't. But when we said git submodule update, what git does is it looks and says, what commit should the brand be at? And it checks out the commit the brand should be at.
[13:09]Oh.
[13:11]Okay. So we now need to say...
[13:13]That's one of those things that your script did for us, right?
[13:16]Well, scripted this time, but we would have been in exactly that place where we left off last time.
[13:22]Right, right, right. Okay.
[13:24]Yeah, because the sub-module works by saying, this folder is this repo at this commit. Not at this branch, at this commit. Why does it do that?
[13:35]That's mean.
[13:36]Because otherwise, spooky action at a distance. this way you have to proactively move the branch forward so sorry move the sub module forward so imagine the brand had done lots of work and we wanted to take that change in a controlled way if the sub module went off on its own we'd be like ah this isn't where we left it so it stays at the commit so it's reliable okay it's not a.
[14:02]Problem yeah okay
[14:04]We want to make a change So we have to tell git, what branch is this new commit going to go on? So at the moment, there's only one branch in our brand. It's the branch main. So we just say git checkout main.
[14:23]So the submodule will stay at the same commit, but now it'll have a head that's main?
[14:30]Precisely.
[14:31]Huh.
[14:32]Because we were already fully up to date, right?
[14:36]Okay.
[14:38]So we're basically saying, I want to stick my new commit here at the top of main. That's still weird.
[14:46]It's still a little headbendy for me, but okay, I'm with you.
[14:49]Right. So now a git status is exactly what I want. Unbranch main, up to date with origin slash main, nothing to commit, working tree clean. Thumbs up, thumbs up, thumbs up. Perfect. This is what we always like, right?
[15:04]
Enhancing App Functionality
[15:05]So when I say the developer wasted a lot of time on Google fonts, I mean me. I picked a very rational font called rationale, and a very nice shade of red. And then I updated style.css. So I added the font with the new import url and then i added the class numeric which says font family rationale font style normal blah blah color red okay.
[15:37]So you could spend time on on uh uh emoji
[15:41]You have.
[15:44]To have that outlet
[15:46]There should be a christmas tree emoji somewhere on that page shouldn't there yeah and a santi maybe anyway right so you could make the change yourself or i made the whole file for you so you we can copy the updated version over the current version with the command in the shells. So now, if we do a git status, we see what we would expect. Change is not staged for commit modified style.css. We did that. So let's commit it. Git commit minus am feet and support for displaying numeric data. Git push. So that's the submodule done. So we have now pushed our changes up to the brand and the content of the brand folder is correct. So let's now step back to the outer module, the one for our app, and see how the world looks from that point of view. So CD dot dot.
[16:44]Hang on. So we have pushed where? We pushed to... So brand is the name of a folder in our local... Yes. But it's...
[16:57]It is the repository pbscord-brand on the pretend git server.
[17:04]Okay, so we've sent it up to the real people. They're going to find out that we were touching their brand. Okay. Yes. All right. Yes.
[17:12]So now we step back to the parent repository, the one for app1, which contains the brand folder. So now let's see what it sees. What's its view of the world? So git status. on branch main, your branch is up to date with origin slash main, changes not staged, modified the brand. It's not at the commit we last saw it. It's at a new commit, our commit. So it's a different commit. So that's a modification. Modified index at HTML, because we added that extra class, display-3. So two changes. Okay, great. Let's commit them then. git commit minus am feet improve the display of countdown numbers to address customer feedback git push now we're done.
[18:03]Okay, so when we're up a level, looking down at brand, our upper level doesn't care what branch or commit. It cares about the commit of brand, which will grab all of the stuff inside. But we don't care what commit it was on inside. We don't care what branch it was on inside.
[18:24]We don't care what branch. It doesn't. And we change one file, and we see it as one change, just the new commit. But if we had changed 500 files, it would still be one change.
[18:35]Yeah, that's interesting. Okay.
[18:38]Yeah.
[18:39]All right. I'm with you so far. That was the easy one.
[18:43]Yes. Okay. So now let's do a very real world example. This is what I do for real, well, did before I became CyberCury Specialist. When I was a sysadmin, this is based on how I actually managed plugins in something like Moodle. I would use this process to do it in a controlled way. So we're going to simulate that by saying that the bigwigs in corporate HQ have decided we need to rebrand. While we were a new company, the very roundy, cuddly fonts were great, right? They're very roundy, very friendly, not very professional. We want a new brand. It should be elegant, pastel colors, very stylish, a little bit art deco, more refined. So we need to go a whole new branch, a whole new brand, which means either we change all of our apps in one go, which is terrifying, or we have the two brands exist in parallel for a while. We let apps stay on brand one for as long as they need to and let apps begin to move to brand two at the same time. And realistically, there might be bug fixes on brand one while we're already working on brand two. So we definitely do need two parallel branches.
[20:07]This does sound funny that, you know, it would be terrifying to have the brand go out, you know, change overnight. But imagine this was a functional change, not just how it looked on a web page.
[20:18]Yeah, exactly. So we're going to lay some groundwork here. So this, we're a young company, PBS Core. This is our first 2.0, right? Nothing else we've done has gone 2.0. And when we started the company, there was one sysadmin, horribly overworked, did something that was functional, but not future-proof. Now it's time to pay some technical debt, I believe the management phrase is. So we have an explicitly set up, but the company's been using a very simple branching policy on their repositories. One production-ready, sorry, only production-ready tested code gets committed to main. So if it's main, it's ready to go. Any experimentation you do on a WIP branch like we do for our show notes, now we have a version two so we're going to have a one point star version of the brand and a two point star version so we have to rethink all of this um so long story short we're going to have new master not master not let call them that two new primary branches for these two production-ready versions of the brand. So we're going to call them stable-v1, stable-v2, and no prizes for guessing what we'll do next time, stable-v3.
[21:46]This gives us a minor quandary. It's normal to have main exist in a Git repository. It's the default branch. You can technically remove it, but you will confuse everyone. It's like weird. Repositories have a main. Yeah, exactly. So when you look at the real world, the choice they make is to use main as a way of saying which of the stable branches is currently the one we consider primary, the one you should use by default for something new. And so they keep it in lockstep with one of the other stable branches. So when I see this in Moodle, before they start work on the next release, they have main pointing at, say, version 3.9. And they also have a 3.8 and a 3.7 current getting bug fixes, but main is in line with 3.9. And then they start working on 4.0, but they keep main there until 4.0 is ready to be what you should use for a brand new Moodle server. And then they move main up to 4.0.
[22:57]That makes a lot of sense, because you're going to be messing around with these lower-level ones that you're just doing bug fixes, maintenance, and stuff. But Sally joins the team, and she's going to set up a new one. You want Sally using what's obvious, main, and that will take her to 3.9 until 4.0 becomes main. But at least she's going to start. You don't want her to start on the one that you're just doing bug fixes and maintenance on and then have to do some weird upgrade. Okay.
[23:24]
Branching Policy Changes
[23:25]Yeah. Interesting. That's a convention. you don't have to do that but seems what everyone does so let's let's do the same here in our little pretend company management are really splashing out though so we're not just making that one change, we've also invested in twice as many servers we're going to have a test environment so that we can safely play with things then put them out for our.
[23:49]Little companies growing up
[23:50]It is and our little company is doing things by the book so they're going to connect a branch to this test server using CICD which is basically automation that you connect to git so if someone pushes to this branch it should move the code to this server and so we're going to name that branch staging, So changes get staged, tested, and then they're allowed to go into stable main, whatever.
[24:24]Okay, and again, CICD you've defined in here as continuous integration, continuous deployment. Boy, does that sound like corporate speak or what? But what that means is that's just the automation that's triggered by Git actions. That's what Helmut does to us, right?
[24:38]It is, yeah. The spell checker fires and all sorts of stuff happens when we push to the repository. Yeah.
[24:45]Yeah.
[24:47]Okay, so now we have a way cooler, more mature policy here, right? Our branching policy is now five points. Only production-ready code should be made to main or any branch that starts with the word stable. So if it's main or stable, it has to be real code. Repositories that have not yet reached 2.0 can keep working the old way. They have one production-ready branch, it's called main. Any project that goes 2.0 has to adopt the new naming convention. So they have to get a stable-v1 for the old code to continue getting bug fixes. And they start work on version 2 on stable-v2. And they keep main pointing at the default they want. So initially v1.
[25:38]It's still v1 at this point. Stable v1.
[25:41]Exactly. Yes. All right. And then at some point in the future, it'll become two. Yada, yada, yada. Okay. Any testing of code should be done on a branch named staging, because that's connected to the testing server. And any experimentation that isn't even ready for that goes on whip, dash, whatever you like. So that's your playground, right? Do whatever you want. And then when you're ready to test it, you put it to staging. And then when it passes testing, it goes to stable. and that is very real world very very real world.
[26:14]
Implementing New Branches
[26:15]Okay, so the sysadmin has some work. The sysadmin has to add various new branches. It has to make sure that app1 and app2 have their staging branches and that the brand design, or sorry, the brand repository has a stable v2 and a stable v1. So, you know, a bit of work to do here. Right, so we have four subparts of scenario five that the show notes will label A, B, C, D if I've done a little bit of CSS right. So we're going to call them scenarios 5A, B, C, and D. So A is the sysadmin doing their homework. B is the brand designer actually making us our cool new Art Deco pastel colored beautiful new theme. Step three of C is the developer of app one updating their app on staging. So they're going to take their current working app one, move it over to staging, so just branch into staging. And in staging, they're going to pull in that scary new theme, open it in the browser, make sure it's all good. And then it's going to go to main on their app because their app isn't changing version. It's just picking up the new theme.
[27:36]Okay so we're not going to version two yet
[27:38]No for now let's just have one v2 on the brand let's not get carried away okay now the cs min has a bit of cs min sys admin i only did it for 20 years, uh they have a little bit of work to do uh which i have scripted and this is really funny because the ultimate sys admin t-shirt is i could replace you with a small shell script and I have just replaced the sysadmin with a small shell script.
[28:08]Oh, Bert.
[28:11]Okay, so what the small shell script does is sets up all the branches. So there's a lot of names here. So I'm going to put them in a table in the show notes, and we'll just cut through them quickly. So in PBS Core brand, we have three branches. Main, which is right now aligned with Stable V1. Stable V1, which is our existing brand, ready for bug fixes. Stable V2 will become our new brand. but right now we've branched it from v1 and made no changes yet so it is also the same as the other two.
[28:46]For now so main stable v1 stable v2 are the same stable v2 will start to do new functionality stable v1 is about to get the new branding v2
[28:56]Is getting the new branding, v1 stays where it is v2 is oh.
[29:02]I thought you said that i was confused i thought you said it was going to v1 i thought that was kind of weird but makes more sense it's going to v2 okay got it So that's BBS Core brand.
[29:10]Yes. And App 1 and App 2 are exactly as they were, but they now have a staging branch, which is just connected to the test server.
[29:20]So they just have main and staging. They don't get this stable v1, stable v2 thing.
[29:25]Not until they're mature enough to go to a v2. I don't know what that would be for a countdown to Christmas. Countdown to New Year as well? Two-timers, I don't know.
[29:35]Okay.
[29:36]Anyway, they stay there where they are for now. Okay, so it really helps.
[29:40]To keep it in my head.
[29:43]
Brand Design Overhaul
[29:43]Scenario 5B, then, we're going to do our work. We're going to make this new brand. Again, I wasted a lot of time, a lot of time, finding very nice fonts and colors. I have to do two bits of work here, right? Anyway, all of my work is sitting ready for you just copying, right? So before we do that copying, we're going to put on the hat of App2's developer. It is App2 we're doing, isn't it?
[30:13]No, we're doing the brand designer. Yeah.
[30:16]Oh, the brand.
[30:17]Sorry. We're doing the brand first.
[30:19]Yes, we are. Right. So we're going to go to PC brand designer. And in PC brand designer, we're going into PBS core brand, which is where the brand is checked out. We're going to do a git fetch to make sure our PC is fully up to date with the pretend server. It is, but let's just do it. Good practice. And we will see actually sorry i intentionally didn't actually do git fetch as part of the script because i wanted you to see it happening here so when you do the git fetch what you actually see is the two new branches new branch stable v1 new branch stable v2 so.
[31:00]You say oh that's because the sysadmin did it to us
[31:03]Yes exactly sysadmin did it on the server and we've now fetched from the server so we now see that they exist okay we want to start using this wonderful new branch git cheho stable v2 okay.
[31:19]Because we're the we're the brand designer we're about to mess with the brand
[31:22]Yes we are okay so we don't have.
[31:25]To work on a whip we get to just go wild over on stable v2
[31:29]We do because this is the first change and imagine we'd spent a week on whip, And we're just going to jump over that. That was me faffing about in Google Fonts. So we're ready to go. So you could make all the changes manually, but there's a lot of them. So you can copy a full version of the new style sheet with the command in the show notes. And now it's ready to be committed. Git commit minus AM feet. Initial release of V2 of the PBS core brand. and ampersand, ampersand, git push.
[32:07]How come your show notes don't tell us we get to go refresh the web page?
[32:11]Well, they don't now because I've only updated the CSS file. We're not going to see it until we become app developer one, which is what we're going to do in two seconds here. Then you can see.
[32:21]Ah, gotcha. Okay, fine.
[32:24]It's pretty, I promise. I'm overselling it now. Anyway. Right. Scenario 2B done, or 5B done. Now let's do 5C. We are the designer, sorry, the developer of App1. So we want to move to the folder PCApp1Dev, PBSCoreApp1.
[32:44]
Developer's Integration Process
[32:44]Now, we want to do a fetch on everything. So not a pull, just a fetch. We want to learn what exists on the server, but not just for App1, also for the brand. So git fetch minus minus recurse minus submodules. So that fetches everything.
[33:05]We got new branches all over the place.
[33:08]Right. Because we have our new staging branch on app one, which the sysadmin did. And we have two new branches on the brand and a whole new commit. So there's a whole new commit has come into main as well. Well, actually, no, it hasn't. Sorry. No, I stayed the same. Sorry my bad but it has two new branches yeah okay yeah it has two new branches right that's what we expected so we now want to do our move to the new brand in a controlled way so we're going to say git checkout staging okay we do it git status characters here yeah we do it git status, you're on origin state or so you're up to date with origin staging nothing commit working tree clean great we want to go right into the brand sub module cd brand we do a git status in here, and we are on our detached head again no.
[34:08]Not a detached head
[34:10]Okay oh my god french revolution terrible right not a problem because we really want to make a change here right we don't just want to say i want the same commit but i want to tell you what branch we're going to change everything, get checkout stable v2 so we're going to a whole new commit here okay.
[34:31]So we were we were told in a staff meeting that this is where we would go find the new branding i'm guessing
[34:36]And we saw it come in right we saw a new brand staging a stable v2 so we saw it exist and we would have been told in a meeting right yeah exactly team meeting big celebration brand is ready folks check it out Stay with me too. So the brand folder is now updated. So let's step back to the parent repository for all of app one, and let's see what it looks like from there. Well, okay, so we CD back, but we were at the meeting, we paid attention, and we were told that numbers need to have the CSS class numeric, otherwise they won't look pretty. And the app two developer did that in scenario four. the app one developer has only just caught up so the app one developer is now going to add that class to their output because they show okay so.
[35:30]I'm sorry i'm going to open my index.html because i want to see the new uh the new thing that we're on so pbs core uh app one is our random number generator but our number just is a little mono space one six doesn't look like bart spent any time on the internet at all looking for funds but my that that fool over in app 2 man made that change we got to i got to bring this new brand thing in geez exactly
[35:58]So class equals numeric right it's not actually a big change great you can use the command in the show notes to stomp a fully updated file over in nix.html but it really is one line right that's changed the big change of course is inside the brand repository so when we do a git status we see two modifieds index at html which is just our little change and brand which just says yeah there's a new commit it's a pretty significant new commit but from its point of view just a new commit so we can commit it by saying git commit minus am feed migrate to brand feed to wait.
[36:39]A minute did we make changes in brand
[36:40]Well we said checkout stable v2 inside the brand folder we said git checkout stable v2 that's.
[36:51]A new commit to pbs apple a core app one
[36:54]Right because it's now.
[36:57]It wasn't there we didn't create a new commit in brand we we checked something out which now made it that's to commit change to the upper level, to the app.
[37:08]So the commit that is currently checked out has changed because we said check out this other branch.
[37:17]Right. That's the change though. That's the commit. We didn't actually mess around in the brand. We didn't touch the brand. We didn't change a font. We didn't fool around in there. It's the fact that we checked out a different branch. That's now a new commit to app one.
[37:34]And you changed to the brand. Okay sorry i see what you mean yes it sees that folder as being at a different commit yes yeah.
[37:46]Then it was expecting got it okay
[37:47]Yeah yeah then it was told before so that's why it's a change so we can commit it here feet migrate to brand v2 git push, now you can open your browser because what's happened now by us doing that push is the imaginary CICD magic is happening and it's now on the test server, which you can simulate by opening the file in Safari.
[38:12]Okay. Now that doesn't look like the same font as what we had over in the digits.
[38:20]Well, no, because I've updated how, right?
[38:24]That's right. That's right. This is a fancy new branding. Don't we look professional now?
[38:29]I think so. I kind of like it.
[38:33]
Merging Changes into Main
[38:34]Okay we're ready so we've made a change we've tested it on staging so now we're ready to bring that change into the main branch of app one so that's scenario 5d is to make that production, so as we learned way back in installment 107 if you're doing it on the command line to merge anything into main you have to be on main and take the change into yourself we're used to the gooey and get cracking where you can drop and drop and it's perfectly happy but no no no we have to do the old-fashioned way go to me you.
[39:11]Know bart i always obey that though you always say i could do it without checking it out but i always check out main first because i'm always afraid i'm going to end up in some you know discombobulated state that i don't know where i am
[39:22]Safer to be honest i'm lazy sometimes bites me okay.
[39:28]So git checkout main but now what happens
[39:31]We've now changed to main and when we do it git status things are not as we expect we have we have reverted app one but we've left the brand behind it's still at its new commit so git status is seen as modified so we haven't fully checked out main we're half in the two universes i.
[40:00]Don't follow you what
[40:02]Okay so normally if you're on a whip and then you check out main everything changes to how it was on main everything right that hasn't happened why our code changed we left the other stuff behind because we changed branches in a not submodule aware way. We did this the old way because we weren't thinking. We have to do that branch change more sensibly. So it doesn't work because we did it wrong.
[40:42]Okay, I don't know where we did it wrong.
[40:45]Okay, we told the outer module to change its branch without telling it to also change what's checked out in the submodules. So we're in a universe between realities.
[41:04]We we checked out a new uh commit a new branch the staging branch on the brand
[41:13]Yes and.
[41:14]Then and then we went up a level and then we we that that became a commit that we needed to make to which we did that and we did that and then we switched to main how do we do to run
[41:27]We only switched the outer repository we didn't tell git we wanted to update the submodules the submodule was not changed by that git share so it's in the state appropriate to staging not in the state appropriate to main so it sees the brand as being at the wrong commit which is why it says and we haven't.
[41:53]Pushed it we haven't pushed it to mean why how could mean possibly know about it
[41:56]But we're not trying right the problem is main sees it because we left it behind we didn't check out the correct so the correct uh commit of the submodule.
[42:15]Okay, imagine we're a train. The submodule change isn't in main. We haven't pushed into main. I know that. So how could, main doesn't know anything yet. But main doesn't know anything. All we did was we made a bunch of changes in this one commit. Then we checked out main. It shouldn't know anything that we did in the commit, much less the brand change in the submodule.
[42:36]Okay, but main knows what commit that submodule should be at for main. It kept a record of the commit it wants to see inside the brand folder oh.
[42:48]There's no way i'm ever going to follow that okay so main wants it to be something
[42:54]Main has an opinion no it has a version what main stores is the folder brand is connected to that repository at this commit. That's what it knows reality should be. It has saved the commit I want from the repository. Put it in that folder. It's a link to a specific commit.
[43:21]Okay, but we... I'm still stuck on... We made some changes in something. And then we checked out in some branch. Then we checked out main. Which is a different branch, it shouldn't know anything. So we should have to merge. We haven't merged anything yet.
[43:44]Right. You are correct. From Main's point of view, the brand folder is supposed to be at the old commit. Right. It's not.
[43:57]Okay.
[43:57]We physically changed the files and we did a checkout of main without telling it also has to put the brand folder to the right commit. It's like we were on a train pulling a carriage and we came to switch and we didn't hold on to our carriage. We were just hoping it would coast behind us. We switched track and our carriage is wrong.
[44:21]I feel like I don't know anything about Git right now because normally if i if i make some changes in whip and then i go check out main in the in the case of the show notes we've got whip 140 174 i check out main main doesn't know anything about those changes because i haven't said to merge yet i need to merge that stuff in for it to even know that that exists but you're saying that main somehow magically knows i made those changes even though I haven't merged yet.
[44:53]No, no, no, no, no. Main knows there should be no changing. It knows the universe should look unchanged from the last time you were on Main. Okay. It knows that should be true. Okay. The problem is the brand folder is wrong. It does not match the reality the branch Main specifies.
[45:18]Okay, I didn't merge yet. That's how come it's not there?
[45:24]No, no. The problem is it is there.
[45:26]
Troubleshooting Submodule Changes
[45:25]Maybe I should let you keep going.
[45:26]No, the problem is it is there. We didn't clean up.
[45:33]I'm going to have to let you keep going because I can't see it.
[45:37]No, this is vital. We can't pass this. This is vital. Imagine, no, no, no, no, please. if you have a normal file on main and you have it open in a smart modern text editor when you check out main you'll see the file change yes yes imagine you had a really old file browser which doesn't keep sync with the file system and when you change main what you see in your text editor does not change and what's worse is the text editor has a write lock on the file so when you checked out main the file got stuck the file is wrong it shouldn't be but it is by changing to main without doing it in a submodular way we have unnaturally held the brand folder in the wrong state main is angry main knows what should be in brand and it isn't right because we have not allowed the brand folder to switch back to its old state and.
[46:57]So, I see what you're saying, but I'm still stuck on something completely separate, which is I make a change to something in a branch. I commit. I push to that branch. Then I switch to main. Then I merge those changes in. We haven't done that step yet. So, how does it even know? It doesn't even know yet. Main can't know anything, much less the submodule problem.
[47:25]Right. It doesn't know. What it knows is the universe should look exactly like I left it.
[47:31]And it does, because I haven't merged. It doesn't know I made changes over there yet.
[47:37]No, no, it shouldn't. It shouldn't know. We have broken the universe. The brand folder was left.
[47:46]Tell me the step we did where we broke it.
[47:48]Git checkout main. That should have changed all the files to be how it was last time. We have broken the universe. The brand folder.
[48:01]So somehow, just because it's a submodule, it doesn't change when you get checkout main.
[48:07]Yes. Unless you say.
[48:10]Now I see what you're saying. So get checkout main would change everything else we were doing back to the way it looked when we were on main, but the submodule doesn't because we didn't hold on to the carriage. We didn't hold on to the carriage. That was 12 minutes of everybody's life. They'll never get back.
[48:29]Yeah, but vital. Really important. So we changed track wrong. Let's back up. Git checkout staging. We're now right back where we started. But now we're going to go from staging to main correctly. Git checkout minus minus recurse minus submodules main.
[48:55]Okay.
[48:57]Now you see the universe exactly like you wanted to see it. Everything is how it used to be. The old brand, the old HTML file, none of our changes. Zero of our changes exist here, as should be true.
[49:18]
Finalizing Updates and Push
[49:14]So if you open your browser, hit refresh, the ugly brand is back. Okay so the minus minus recurse sub modules is vital when you have sub modules, okay your gui will do it for you but on the command line you will get this wrong i speak from experience took me a while to figure out why wouldn't.
[49:40]Our our saying get check out main, you've got in the show notes what it was we saw, but, or I'm sorry, after git status, what in there told you, whoa, I did it wrong?
[49:53]Two things. So at the moment in time we said git share main, the normal output is two lines. Switch to branch main, your branch is up to date with origin slash main. But the actual output was three lines. S1, M, brand. Brand is in a modified state. Why is the brand in a modified state? We told you to go back to how reality was, and you've left that folder wrong.
[50:24]So the line he's talking about just says, it's just M sitting on the left and then the word brand. That's all it says. It doesn't say you left something behind. It just says, brands modified. I'm just, I don't know what I'm going to do.
[50:40]Yeah. Now, that's not obvious, which is why I'm saying, in hindsight, if you scroll up, you'll have seen that. But you won't have noticed. I didn't when I was writing the show notes. Where I noticed it was when I did a git status. And it said modified brand i was like no the brand should be right where i left it why isn't the brand where i left it git went to the git book opened the chapter on sub modules read it again and went oh yeah i forgot the flat i forgot the minus minus recurse sub modules main okay when you do it that way your output from the actual checkout is exactly the two lines you want, which is just switch to branch main, your branch is up to date with origin slash main. And git status is the three happy lines of magic on branch main, up to date with origin, nothing to commit, working tree clean, right? They're the three happiest lines when you're a git person.
[51:41]Right, right.
[51:42]So now we are ready to do exactly what you know we need to do. Git merge staging.
[51:49]Oh, I feel so much better. We finally got there. thanks for staying with me on that I just thought I was never going to get there but okay so now we do git merge staging
[51:58]Yeah now it now knows what the new desired reality of that submodule is do you want to guess what it didn't do, It's actually changed the content of the folder to match the new reality it knows should be true. It knows what it wants. It hasn't done it. So if you do a git status, it's showing us that main, sorry, that brand is on the wrong commit. Modified brand. Oh, why?
[52:34]Wait, wait, hang on. We just did the git merge staging. Yes. You didn't talk about what it says, this brand two plus or minus thing.
[52:43]Okay, so it is saying that when we merged in staging, two things changed by the act of merging in that branch. Indexed HTML changed, and the commit the branch should be at changed.
[52:59]It says two insertions, two deletions.
[53:02]Yeah, it took out the old commit and put in the new commit. It took out the old HTML line and put in the new HTML line.
[53:10]Okay. Okay, so now move on from there. I wasn't able to focus on that because I wanted to understand that part. Okay.
[53:18]So now when we do Git status, it knows what the brand should be. It should be the commit with the shiny new brand on it. But it hasn't physically made that true. It just says, yeah, I know what you should be. And when you do Git status, it says, oh, that folder's at the wrong commit. That folder is at the old commit for the main branch not the new commit well the magic command to make submodules be correct is git submodule update that makes the physical folders match the desired reality so it knows what committed wants it just hasn't done it, i don't know why by the way if i was deciding this i would have git submodule update happen automagically just always yeah.
[54:08]Why would you not want to do that what would there's got to be some circumstance under which you don't want that but
[54:14]There's a circumstance in which it would break if you're on an airplane and the remote server was genuinely remote you couldn't get the new commit, okay i don't see that as a reason not to have it be the default by the way but yeah yeah there's lots of questions on stack overflow and everyone asked this question and the answer everyone gives is, it's really annoying.
[54:44]All right so now we have a submodule path brand has a commit
[54:48]Yeah and.
[54:49]Now when we refresh we get to see the pretty new fonts
[54:52]Yeah we're ready git push that's it all right our new web app has now been pushed to the server we have updated App 1 to Brand 2. In a controlled way.
[55:11]I'm really intrigued here. I know you thought I gave you all of my questions because I gave you so many questions in the last three days since you've been rewriting this. I had more on a sticky note on my screen here, not a physical sticky note, but like, wait a minute, why did we do this? Why did we do that? Why did we do that? And now I understand.
[55:30]Excellent.
[55:31]I couldn't figure out what that last 5D was even what we were doing when I first read it. So this is one that luckily everybody who's listening to this is listening to this.
[55:43]Yes, and this is a heavy lift, right? This is the pinnacle of Mount Git, right? Oh, sorry, of our exploration of Mount Git. There are one or two peaks in the vague distance we may venture towards someday. Rebasing is one I'm on, maybe, maybe not. You're going to see it on more and more Git clients. Not for at least six months i do have to say that.
[56:10]The the first 12 times i've run into problems with the sub modules that you're about to foist on me uh in the show notes i will you don't get to say i already taught taught you this because i'm going to ask you again and again and again and again
[56:25]Interesting news there so you in this scenario are the brand designer you don't have to worry you about sub modules I do I'm app one developer you want a subset of my giant big folder of nodes so you get to be the inner one I have to merge
[56:49]
Conclusion and Next Episode Teaser
[56:44]the inner one into my bigger outer structure so my problem my blood.
[56:49]Pressure just dropped
[56:51]Yeah it's just literally not your problem just ignore it my problem, I'll learn a lot.
[56:59]Okay, good, good. All right, so this is the finale of the Git submodule series. Is this a series within a series then?
[57:09]I guess it is, which is a series within a series within a series. Exactly. Which is really appropriate, right? Nesting all the way down, turns all the way down. Exactly. I'm going to wrap it up with a very quick summary. We've talked a lot, but in reality, you just need five new commands in your arsenal. Git submodule init is what you do the first time you clone a repository that has submodules. It just makes git's internal database match the .git module file that says how it should be. Git submodule update makes the physical folders for the submodules be at the right commit so when you change branches or anything and the folder's in the wrong place git submodule update makes reality match the desired reality the specified reality Yeah, actual reality becomes specified reality.
[58:13]They go into sync.
[58:16]Git checkout minus minus recursive modules name of branch is how you switch branches completely. My main repository changes branch and all the submodules do what they're supposed to do. Git fetch minus minus recursive modules says, fetch the new reality everywhere. All the new realities. Get them all in one go. Git submodule update minus minus remote says, get the latest version for the appropriate branch of every single submodule. Rule them all forward at once. I never do this because the whole point is you're trying to be controlled and do things piece by piece. Update everything. Is not controlled. It's the opposite of controlled.
[59:11]But you taught us how to do it anyway.
[59:14]Exactly. Exactly. And that's it. So arguably, three installments could have been those five lines. Only they wouldn't have been much good here.
[59:25]Exactly. Exactly. The understanding definitely wouldn't be there. Well, I'm glad I did my little pitch, rah-rah-bart, at the beginning, because I appreciated even more going through all of this with you. I think at this instant in time, I understand.
[59:41]Excellent. And I will also say one more thing, right? So you're right that it's a lot of work, but I choose these topics for dual reasons. They're things that are both helpful to the audience and that I want to learn better. So I needed to get better at submodules. I understood them enough to be dangerous.
[1:00:05]Muddle through.
[1:00:06]Yeah, muddle through. That's a perfect description. And now I understand them. So i i'm really happy i spent this time and it's half for me and half for you.
[1:00:15]All right all right well and for the audience of course
[1:00:18]Yeah it's half for all three of us uh okay magic right folks we're going to be changing topic completely next time and i think there's a tidbit as a sort of a separator so next time we're going to explore why we care about something called the Static Site Generator and why it matters to programming by stealth. And then we're going to learn how to actually do it and make free websites for ourselves on the real internet using the magic of GitHub pages. So yeah, free stuff.
[1:00:55]Yes. Nice.
[1:00:56]Until then, lots and lots of happy computing.
[1:01:01]If you learn as much from Bart each week as I do, I'd like you to go over to lets-talk.ie and press one of the buttons over there to help support him. He does 98% of the work here. I'm just the stooge that listens to him and asks the dumb questions. If you go over to lets-talk.ie, you can support him on Patreon, you can donate via PayPal, or you can use one of his referral links. I really hope you'll go over and help him out. In the meantime, you can contact me at PodFeed or check out all of the shows we do over there over at podfeed.com. Thanks for listening.
[1:01:36]Music