Programming By Stealth

Latest Episodes:

PBS 124 of X – Chezmoi Templates Sep 04, 2021

Show notes

Bart has been really excited to teach this next installment of Programming By Stealth where we really dig into learning about Chezmoi templates, including learning functions and arguments, how to declare variables, looping over arrays, and learning the `sprig` utility functions to extend Chezmoi. I thought he was going to jump out of his chair he was so happy to teach pipelines which are a grand way of embedding function statements in a way that is very human-readable.

This is our penultimate installment on Chezmoi, where next time we'll be learning how to manage our dot files across multiple computers where not everything is the same between computers, but much of it is.

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

PBS 123 of X — Backing up and Syncing Dot Files with Chezmoi Aug 22, 2021

Show notes

In this week's episode of Programming By Stealth, Bart Busschots continues his instruction on how to use the open source tool Chezmoi to manage our dot files, those hidden configuration files on our Macs. In this installment, Bart teaches us how nearly effortless it is to sync our Chezmoi-managed dot files up to a private repo on GitHub. Seriously, it's like 2 steps.

Bart then teaches us how Chezmoi supports templating. When Bart started to describe it, I said, "Oh! It's just like mail merge in Microsoft Office!" He laughed, and said he hoped I would say that.

With Chezmoi, let's say you have your email address in a bunch of your dot files, and you need to change it to a different address. If you use Chezmoi's templating feature, you can create one file with your email address and in every dot file you reference that address, and only have to change it in one place. Bart walks us through a couple of worked examples to help us see exactly how it works and get a little practice.

The next episode of Programming By Stealth will end this mini-series within a series, and if Bart's work manages to finally slow down to where he can get some good thinking time, we should start up learning about PHP shortly after that.

As always you can read along with Bart's spectacular tutorial shownotes at pbs.bartificer.net/...

PBS 122 of X – Managing Dot Files with Chezmoi Aug 08, 2021

Show notes

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/....

PBS 121 of X — Managing Dot Files and an Introduction to Chezmoi Jul 23, 2021

Show notes

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."

PBS 120 – Ignoring Files in Git Jul 10, 2021

Show notes

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/...

PBS 119 of X — Open Source on GitHub Jun 27, 2021

Show notes

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)

PBS 118 of X — JavaScript Apps with GitHub Pages Jun 12, 2021

Show notes

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/...

PBS 117 of X – Introducing GitHub May 29, 2021

Show notes

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/...

PBS 116 0f X – Team Git May 15, 2021

Show notes

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.

PBS 115 of X – The Push & Pull of Git May 01, 2021

Show notes

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/...

Our TOPPODCAST Picks

Follow Us

Stay Connected

Related Podcasts

Links

Stay Connected