Programming By Stealth

In our previous installment of Programming By Stealth, Bart introduced us to Chezmoi, an open source tool to help us manage dot files, those hidden configuration files that get created on our Macs. Configuration files contain information about how we like our Macs configured, including where to access our ssh keys and our preferred command line editor and more. If we move between computers it would be nice to have the same configuration, or if we do a clean install it would be great to be able to have these dot files in place on our newly-formatted machines.

He teased us last time though but just introducing us to Chezmoi and not letting us do much. In this installment he lets us take Chezmoi out for a spin. We edit an environment variable to set our preferred text editor, and then use Chezmoi to talk to Git to add and then commit those changes. Along with more changes and actions with Chezmoi, Bart works hard to cement the terminology of Chezmoi because without it, it's easy to not realize what Chezmoi is doing under the hood and it could cause problems in the future.

You can find the shownotes for this episode at pbs.bartificer.net/....

As we've become nerdier while learning from Bart, we had started to add hidden configuration files to our Macs and PCs. On the Mac, these configuration files hidden by default by putting a dot in front of them, and hence they are called dot files. Maybe you've stored your ssh keys, or in our Git series you created a user-level gitconfig file, or perhaps you've installed VS Code or Sourcetree which also add hidden configuration files.

In this installment of Programming By Stealth, Bart explains the problem to be solved of how we manage these configuration files if we use multiple computers or migrate to a new computer or do a nuke and pave. He lays the groundwork for why he loves the dot file manager called Chezmoi from chezmoi.io.

The installment is a bit of a tease because after learning why we want to have a dot file management tool and why Bart favors Chezmoi for the job, he only lets us install it and run two commands before he says, "And next time we'll start to use Chezmoi."

A few weeks ago I told Bart off the air that when he was done with his mini-series within a series all about the version control system Git, I'd like a few minutes with him offline so he could explain how to ignore files in Git. I knew there was a way to do it but he hadn't covered it so I assumed it was just something quick he could explain to me. His reaction surprised me, he said, "D'oh!" because he realized that this is a _very_ important part of using Git and that he would definitely dedicate an installment to it.

So this week Bart teaches us how to use `.gitignore` to tell Git _not_ to track changes to files and folders. He explains that there are files your computer or even your code editor may be creating that you don't want Git to track, and of course there all of the dummy test files we as humans create that would not be something we'd want to share with our co-workers or fellow open source contributors.

I was nervous about using `git ignore` because I understood it relied on patterns, and I thought that would mean something along the lines of using Regular Expressions, which are kind of daunting. I shouldn't have been worried, `.gitignore` patterns definitely don't require any heavy lifting.

I was really looking forward to this installment and it didn't disappoint.

You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net/...

As promised, Bart takes us through the final step in our GitHub journey - learning how to contribute to an open source project. He explains three open source scenarios: using someone's code exactly as-is, using their code with a few customizations of your own, and finally the most interesting scenario, customizing the code and contributing your customizations back to the project.

When he gets to the final scenario, he gives us a way to practice these newly-acquired skills, and it's something he's wanted to do for a long time. He's created a gallery for all Programming By Stealth listeners to contribute their work they've done in the various challenges we've worked in Programming By Stealth. If you have your code from the challenges for Conway's Game of Life, the number guessing game, the currency converter, the currency grid, the world clock or the time sharing clock, we'd love to have you contribute to the PBS gallery to show off your work.

Bart explains that the GitHub Pages he's created will allow us to fork his code, make our own changes, and then create what's called a pull request to get them accepted into the official PBS Gallery at gallery.pbs.bartificer.net. I worked through the process for one of my projects and it was definitely a learning experience, which is the whole point of Programming By Stealth.

Bart's fantastic tutorial shownotes are availale at [pbs.bartificer.net/...](https://pbs.bartificer.net/pbs119)

In this installment of Programming By Stealth, Bart Busschots teaches us how to use a free service of GitHub called GitHub Pages. This service literally gives you free web hosting for the web apps we've learned to make in Programming By Stealth. Bart starts by explaining to us the difference between static and dynamic webpages, and web pages created by static site generators like Jekyll which generates GitHub Pages.

It's trivially easy to create a GitHub Page from an open GitHub repo (literally three clicks in the interface) but it's really important to understand what you're doing when you take advantage of this service. We'll learn what you can do and what you can't do and what you could do if you choose to dig deeper into the woods on how to use Jekyll to generate GitHub Pages.

I'm really excited to learn about GitHub Pages and how easy it is to host all of the web apps we've created in this series.

You can find the shownotes at pbs.bartificer.net/...

In this week's installment of Programming By Stealth, Bart teaches us how to use GitHub as a public repository for our code, or for anything we write for that matter. He reviews whey he chose Github, and then we dig right in. He does explain the benefits of using SSH to access Github instead of HTTPS, and if you haven't set up SSH keys before or you're rusty on the topic, he includes links to our sibling show, Taming the Terminal where you can learn how to do it.

We create a new repo from scratch in Github on the web with a README file and a license, and then we get to use a command line version of Github called `gh`. With `gh` we pull the repo down from Github, we edit the files, we commit them locally, and push them back up to Github all from the command line. We then flip the tables and from the command line create another repo directly on Github, create some files, set them up to track and push and pull again to prove it's working.

It's surprisingly easy and simple. Bart teases us with the next episode where we'll learn how to create a website using Github pages, which will give us a nice place to host our web apps for free. You can follow along with Bart's fabulous shownotes at pbs.bartificer.net/...

In previous installments of our Git miniseries within a series in Programming By Stealth, Bart taught us how to work in Git standalone on one computer, then how to work as one developer with multiple computers. In those installments he taught us the necessary commands and their importance in the Git scheme of things. In this installment he talks about how and where to work with a team in Git. We learn about the plethora of options from free to full enterprise-size Git-as-a-service, and why he'll be focusing on Github for the future. He explains how important it is to set up conventions for your team (before you start) for things like coding styles, development paradigm and more. There's no coding in this episode as it's more philosophical than other episodes.

You can find Bart's fabulous shownotes over at pbs.bartificer.net/pbs115.

When Bart started this mini-series within a series on using Git for version control, he explained that our journey would be in three Phases. Phase 1 was the section where we learned about local repositories, and Phase two was dedicated to learning how to have multiple repositories just for ourselves. In this lesson, we finish up Phase 2 by learning how to push and pull changes from our imaginary desktop to our imaginary NAS to our imaginary laptop and back. I slowed down the class a few times with some confusion I had, but Bart always claims that my confusion often helps other people who might be hung up on the same thing. I enjoyed myself immensely, even when I was confused!

We are about to enter Phase 3 where we will learn how to collaborate with others. We'll be doing this collaboration using Github, because it's pretty much the defacto home for most open source projects. When you're done listening to PBS #115 and studying the shownotes, you might want to get yourself a Github account so you can be ready for the next lesson.

As always you can find Bart's fabulous tutorial shownotes for this lesson at pbs.bartificer.net/...

Last time on Programming By Stealth, Bart introduced the concept of remote repositories, also known as remotes. It was one of those episodes where we learned a lot but didn't get to apply what we learned. In this week's installment we get our hands digitally dirty as we create a _bare repository_ (a repo with no working tree), and declare it to be a backup of our local repo. We learn how to fetch and view remote branches and tags, how to push everything to the remote, and then after making some changes, push them to our remote backup. We're still in a bit of a sandbox as we do all this on one computer inside a couple of local folders, but the lessons exercise our new muscles to get ready for the big leagues.

Bart's excellent tutorial show notes are as always available at pbs.bartificer.net/...

[audio mp3="https://media.blubrry.com/nosillacast/traffic.libsyn.com/nosillacast/CCATP_2021_04_03.mp3"]

mp3 download