Programming By Stealth

Programming By Stealth is a collaborative series created by Bart Busschots and Allison Sheridan, as part of the Chit Chat Across the Pond podcast. If you would like to subscribe to this podcast without the “Lite” version of Chit Chat Across the Pond, use this Apple Podcasts Link or paste this link into your podcatcher of choice: https://podfeet.com/ccatp/pbs-rss.xml


CCATP #793 — Bart Busschots on PBS 165 of X – jq: Variables (5/11/2024) by podfeet

In this installment of Programming By Stealth, Bart explains why jq is uniquely designed not to need variables (most of the time) and then explains how to use them in the few instances when there’s no other way. It’s really a fairly straightforward lesson as Bart sets up some clear examples and solves them with some simple variables. It’s one of my favorite episodes because the problem is clear and the solutions are clear. It really shows off how clean jq is as a language.

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

mp3 download

Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_05_11

CCATP #790 — Bart Busschots on PBS 164 of X – jq: Working with Lookup Tables (3/30/2024) by podfeet

In our previous episode of Programming By Stealth, Bart Busschots taught us how to create lookup tables with jq from JSON data using the from_entries command. Just when we have that conquered, this time he teaches us how to do the exact opposite – disassemble lookup tables. I think this was a really fun lesson because taking data apart, reassembling it the way you want and then putting it back together again is a great way to really understand what we’re doing with jq. I got much more comfortable as I started to recognize the patterns in what Bart was doing. We also get to play with a new data set, the Have I Been Pwned data gathered by Troy Hunt.

If you’re a data nerd, and really who amongst us isn’t, you’ll love this episode too.

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

mp3 download

Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_03_30

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #789 — Bart Busschots on PBS #163 – jq: Lookups & Records (3/16/2024) by podfeet

In this episode of Programming By Stealth, Bart Busschots as usual works through his solution to the challenge from last time, and as usual I learn a lot more about how to use jq to solve problems. He takes a bit of a detour to explain a fun email we got from Jill of Kent in which she explained the vast number of headaches you’ll run into when trying to alphabetize names no matter the language.

Then we buckle down and learn about how to make tradeoffs between speed and efficiency of resources, and how jq lookups can help us. Bart also helps us understand when lookups can help us with querying JSON files.

This episode is more of a lecture, which is fine because he’s introducing a new concept and explaining some philosophy. You won’t hear me breaking into the conversation very much but it’s only because I’m not confused! Don’t worry, when we get into the final example you’ll hear me get confused! Bart explains it about 3 or 4 times and when you hear why your co-host here was confused, it’s kind of ironic.

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

mp3 download

Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_03_16

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #788 — Bart Busschots on PBS 162 of X — jq: Altering Arrays & Dictionaries (3/2/2024) by podfeet

Bart Busschots is back to teach us how to alter arrays and dictionaries in JSON files using jq. Bart went through his challenge solution on cleaning up the Nobel Prize database and I learned a lot from it. Maybe he’d already taught all of it to us before but I sure wouldn’t have been able to put the pieces together.

For the new content, we learned how to alter arrays. We mastered sorting and reversing, how to add and remove elements, how to deduplicate the values within, and how to flatten even nested arrays. From there we learned how to manipulate dictionaries by adding and removing keys.

It’s a very focused lesson that continues to show how powerful the jq language is. I think my favorite part though was when Bart made an existential philosophy observation when he said “Everything exists with the value of null.”

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

mp3 download

Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_03_02

CCATP #787 — Bart Busschots on PBS 161 — jq: Maths, Assignment & String Manipulation (2/17/2024) by podfeet

In this week’s episode of Programming By Stealth, Bart continues to expand our knowledge on how to use jq to query and manipulate JSON files. We learn how to use mathematical operators on data in our JSON files along with fun functions like floor and absolute value. I even contributed some to the learning by showing examples of how ceil (for ceiling), floor, and round produce curiously different results when operating on negative decimal numbers.

We move onto learning about both plain assignment and update assignment. It seems like a small deal but the ability to set a parameter using the plain assignment = vs the ability to update a value using |= is is actually huge and has lots of subtleties.

I think one of my favorite parts was when Bart took us back to our JavaScript lessons and reminded us of how weird it is on one concept but how jq is much more in line with modern programming languages. I felt like a seasoned programmer because I knew the history of what we’d learned. Finally we learned how you can actually divide strings. I know, weird, right? Ok, that’s enough spoilers.

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

mp3 download

Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_02_17

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #786 — Bart Busschots on PBS 160 of X — jq as a Programming Language (2/4/2024) by podfeet

In this week’s installment of Programming By Stealth, Bart Busschots teaches us how to use jq as a programming language. Before we get into the new stuff, Bart takes us through his solution to the challenge, and I have to say I was pretty chuffed when he said my solution to the extra credit portion was more elegant than his. To be fair, it took a buddy programming session with him for me to get the first part of the challenge figured out.

When we got into the programming language part of the lesson, there were so many times that I said, “I needed this last week!” I think finding out these options are available after understanding the problems they solve was fantastic.

We learned how to run jq filters from files, which means no more looking at our filters all on one line – we can put line feeds and indents into our filters to make them more readable. We can even add comments. Bart tells us about a couple of handy plugins for VS Code to give us syntax highlighting which will be swell.

My favorite thing I learned was how to add debugging to our filters. This one is a life changer. We explore a few functions for exploring data filters that will make life easier. We wrap up with an introduction to jq variables, which the developers of jq really don’t want you to use unless absolutely necessary.

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

mp3 download

Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_02_04

CCATP #785 — Helma van der Linden on Porting XKPASSWD from Perl to JavaScript (2/3/2024) by podfeet
Allison Helma Steve outside smiling arm in arm. Helma is wearing an Apple Park t-shirt
Helma Visiting Steve & Me from The Netherlands

This week’s Chit Chat Across the Pond Lite is a stretch to the word “Lite”. I’d call it a crossover episode of Lite and Programming By Stealth. Helma van der Linden joins me to tell the story of how she has successfully started the new version of Bart’s fabulous xkpasswd password generation service. xkpasswd.net was written in perl ages ago and depends on very old and outdated libraries. Bart spent many months teaching the Programming By Stealth students the tools we (and he) would need to port the code over to JavaScript. His plan all along was to have students help him make the new version of XKPASSWD a reality.

It turns out that Helma is an extraordinary student and has done most of the work to make it a minimal viable product, all without Bart’s help. In this conversation, we’ll talk about how she did this without getting too nerdy. Some nerdy but not too nerdy.

If you’d like to give the very beta version of the new tool a try (without knowing any coding), check it out at bartificer.github.io/xkpasswd-js/. In a few days, Bart will have it up as the beta version of the real xkpasswd at beta.xkpasswd.net. This beta version is not feature-complete, but it allows you to create 1-10 passwords that use the default preset from the original xkpasswd. You can’t choose different presets, and you can’t make customized passwords, but at least it does create long, strong, memorable, and typable passwords. And it’s REALLY pretty!

We end with the call for others to come help work on the code. The GitHub repo is at github.com/bartificer/xkpasswd-js. If you have or create a GitHub account, you can contribute to the project. If you don’t have programming skills but you have feature requests, it counts as contributing if you use the “issues” tab for the GitHub project to post your feature request.

Helma is great fun and we had a blast talking about what she’s accomplished so I think you’ll enjoy the conversation no matter how nerdy you might be.

mp3 download

Read an unedited, auto-generated transcript: CCATP_2024_02_03

CCATP #784 — Bart Busschots on PBS 159 of X – jq: Building Data Structures (1/20/2024) by podfeet

In this very meaty episode of Programming By Stealth, Bart Busschots teaches us how to build data structures using jq with JSON files. We’re not just querying existing data, we’re rebuilding the data the way we want to see it. We learn how to build strings with interpolation, which I find is a very odd word to describe the process. It’s really like concatenation in Excel, but maybe that’s just me.

We build arrays using jq, and even convert between strings and arrays with the split and join commands. We build dictionaries in a syntax that is simple and elegant. We also build dictionaries from strings using capture with Regular Expressions.

We learn not to do string formatting and escaping using @ – for example @csv can automatically create comma-separated values data for us and @uri can escape characters for us in a URL we build using jq.

Like I said, it’s a meaty episode but Bart and I both enjoyed the lesson quite a bit.

You can find Bart’s fabulous tutorial shownotes at pbs.bartificer.net. And just in case I forgot to mention it earlier, remember that we now have transcripts with chapter breaks. This means you can jump pretty easily to a topic to reread exactly how Bart explained something. You even get a time stamp of when he talked on that subject, allowing you to easily skim to the portion of the audio you want to rehear for clarification. All thanks to the magic of Auphonic. Ok, it’s not magic, but it feels like magic!

mp3 download

Read an unedited, auto-generated transcript: CCATP_2024_01_20

CCATP #783 — Bart Busschots on PBS 158B – jq More Advanced Queries (12/30/2023) by podfeet

Two weeks ago, Bart Busschots and I recorded a Programming By Stealth episode covering more queries using the jq language on our JSON files. We spent so much time working through the challenges from the previous installment that we only made it halfway through his tutorial shownotes. So this week we’re back with the second half of that episode, Programming By Stealth 158B.

Before we got started learning, I alerted the audience to a significant enhancement to the material we create for this show.

I use a service called Auphonic to do a lot of things with the audio file when we’re done recording, including leveling the audio, adding metadata to it, converting it to an MP3, and FTPing it to the server for the listeners to download. Auphonic has recently added AI-generated transcripts which we’ve had for a while with Programming By Stealth.

The NosillaCast has chapter marks you can use to jump to content in the audio file, but Chit Chat Across the Pond has never had that. Auphonic now adds auto-generated chapters based on the content in the audio file. These chapter marks are in the transcript, which allows you to jump to the text of where we cover a specific topic.

Not only that, these auto-generated chapters are in the audio file so in your podcatcher you can now jump to different sections instead of having to scroll through to find something Bart explained.

The chapter marks are not perfect, and we have no intention of editing them, but it should give you an easier way to find what you want to re-listen to or re-read. While Bart has spectacular tutorial shownotes, the transcript gives you the full flavor of the conversation we have while Bart is teaching me.

Now back to this week’s show! In this week’s episode, Bart explains two powerful commands for searching JSON files with jq, the contains and inside functions. In this context, he goes through testing for containment with strings, arrays, and dictionaries, and he then tells us about default containment. Then he explains how the inside function does essentially the opposite of testing for containment. Finally, he shows us how to use regular expressions with the test function to get as granular as we like with our jq filters.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_12_30

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #782 — Bart Busschots on PBS 158A – jq More Queries (12/20/2023) by podfeet

In Programming By Stealth this week, Bart Busschots and I start off by going through the challenges from our previous installment. Remember how I said I was really digging jq and querying JSON files because at heart I’m a data nerd? Well, I failed completely at accomplishing the homework. It was not for lack of trying though – I worked about 4 hours on just the first challenge. Because of a fundamental building block that wasn’t properly in place in my brain, I was never going to succeed.

That means that this episode is almost half about the challenges and Bart carefully re-explaining the pieces he’d taught us in the previous installment. We both agree that it’s good work because if I was lost, there’s a reasonable chance that one other student was as well.

Because of my questions, we cut the episode in half, so the shownotes are complete but the second half will be explained in PBS 158B which we’ll record in a couple of weeks.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_12_20

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #781 — Bart Busschots on PBS 157 of X — jq: Querying JSON with `jq` (12/9/2023) by podfeet

In this week’s episode of Programming By Stealth, Bart Busschots continues his instruction on learning more about how to use the jq language to query JSON files. We get into the thick of it as Bart teaches us three important jq concepts: filter chaining, operators, and functions.

To get there we learn about the literal values in JSON and jq and how only null and false are false. Armed with that, Bart explains the not function and once we put those concepts together, this ridiculous command will make perfect sense:

jq -n 'true and true | not' # false

I got such a kick out of that when I first read it in the shownotes earlier this week that I posted my enjoyment of it on Mastodon, and one of the actual developers of jq commented that he was excited to learn we were covering jq in Programming By Stealth!

The any and all functions are nearly as silly sounding but are equally useful. By the end of the episode, we can successfully query the Nobel Prize JSON file to show us all of the prizes won by anyone with the surname “Curie”.

We even have three fun challenges at the end of this episode.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_12_09

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP # 779 — Bart Busschots on PBS 156 of X — Extracting Data with `jq` (11/25/2023) by podfeet

After the last episode of Programming By Stealth where Bart gave us an intro to jq and the problems it can solve, this week we start to get our feet wet by learning how to extract data from JSON files. We learn how to descend into dictionaries and arrays, and how to slice arrays. Learn how jq will output sarcasm about “Bart Busschots” if you don’t learn how to ask it for raw output. We even learn how to extract data from multiple files at once and how to extract multiple values from our JSON files. Finally, we learn about exploding arrays and how to suppress errors.

I think I really love data manipulation because I loved this episode.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_11_25

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #778 — Bart Busschots on PBS 155 – Introducing JSON Processing from the Shell with `jq` (11/18/2023) by podfeet

After our annual break from Programming By Stealth that happens at an unknown time for an unknown length every single year, Bart and I are back with a new episode of Programming By Stealth. Bart introduces us to a language called jq and a terminal command called jq which together are used to help query JSON files, see “pretty versions of them, and also to manipulate them.

We don’t learn a lot of commands but Bart walks us through a few examples to help illustrate why we care, or shall I say, “the problem to be solved”? I’m sold on the idea having just mucked about in a config files for homebridge this week.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_11_18

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #775 — Bart Busschots on PBS 154 — Bash: Expansions & Brackets Redux (9/2/2023) by podfeet

Bart Busschots joins us for Programming By Stealth with the final installment of our miniseries on Bash. He explains a few new concepts, but the real value of this installment and especially his fabulous tutorial shownotes is that he compiles a lot of info into some tables for us to use as reference for the future. As with all good programming, Bart is scratching his own itch – he wanted a single place to go to know which brackets mean which and which ones do you have to cuddle vs. not cuddle. He also wanted a table of the order in which Bash processes the seven distinct expansions.

We’re closing out Bash but Bart has a new miniseries on the horizon to look forward to.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_09_02

CCATP #774 — Bart Busschots on PBS 153 – Bash: Functions & Scope (7/29/2023) by podfeet

In Programming By Stealth, we’ve come to the end of our journey with Bash. I’ll be sad to have it complete because as I tell Bart in this episode, I’ve really enjoyed it. Next time he will do a final bow-tying episode where he brings everything we learned together in one set of notes as a handy reference guide.

In this episode, he explains how functions work in Bash, and after about the 12th time he repeated it, I understand that functions we create in Bash work just like built-in functions such as ls or cat.

After walking us through some easy-to-follow scripts to illustrate this and show us the syntax, we go into a harder concept: scope. We learn that Bash does scope differently from pretty much every other language, and so he teaches us how to avoid spooky action at a distance because of this different way of dealing with scope. Protecting ourselves isn’t actually hard but it is very important to understand why we need to do this.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_07_29

CCATP #773 — Bart Busschots on PBS 152B — Bash: xargs & Easier Arithmetic (7/8/2023) by podfeet

In Programming By Stealth 152A Bart and I decided to hold off on the middle of the lesson he’d written up. That middle bit where he said to “put a pin in it” was about the use of xargs. I’m really glad we did skip it in the last installment. It’s a pretty useful concept and deserved a lot more attention than it would have if we’d tried to cram it into that episode. The other good news is that Bart learned a bit more about how xargs does its magic, so he is better able to explain it, and he updated the shownotes with a lot more detail and a great worked example.

As a teaser, the big problem xargs was designed to solve is that there are times when we want the data from the standard input stream (STDIN) to be passed to another command as one or more arguments.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_07_08

CCATP #771 — Bart Busschots on PBS 152A — Bash: xargs & Easier Arithmetic (6/25/2023) by podfeet

I don’t always make the time to pre-read the shownotes for Programming By Stealth but I never regret when I do make the time. That was especially true this week. In this installment, Bart Busschots takes us through his solution to the challenge from PBS 151, which was to print a “pretty” multiplication table using the printf command.

Being Bart, he didn’t just make the columns line up nicely, he took it up a notch and added ASCII characters that build a nice border and corners around his table.

The reason I said it was good I pre-read the shownotes is that while nearly everything he explains in this lesson was a reuse of things he’s taught us before, the commands are so dense in Bash that it was particularly hard to read and comprehend. We had also taken 4 weeks between lessons which made it even harder to remember.

Because I told Bart ahead of time that I was going to be stopping him to ask lots of questions, we decided to skip the one main topic he had planned to explain – xargs. This means that the next installment will start with xargs as Programming By Stealth 152B using the same shownotes. I’m really glad we did it this way because instead of you having to listen to a confused and thus frustrated Allison, the lesson flows well with me having time to ask the right questions.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_06_24

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #768 — Bart Busschots on PBS 151 of X — Bash: Printf and More (5/27/2023) by podfeet

This week’s Programming By Stealth wasn’t a heavy lift but I managed to get confused a couple of times anyway so expect lots of questions from me in this one. Bart started the show by telling us about a clever tip from listener Jill of Kent about how to detect when the Terminal talking to and from STDIN, STDOUT, and STDERR. Then we learn about how to use the printf command to make nicely formatted output. I especially liked that part because I love me some organized output.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_05_27

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #767 – Bart Busschots on PBS 150 of X – Bash Script Plumbing (Take Two) (5/13/2023) by podfeet

When Bart and I recorded PBS 150 on Bash Script Terminal Plumbing, neither of us was happy with it. I got very confused in the middle, and Bart decided that his original strategy might have been flawed in which he assumed everyone had heard Taming the Terminal and remembered everything taught more than 4 years ago. He completely rewrote the shownotes and we re-recorded the entire episode. It was ever so much more fun and I really understood what he was teaching this time through. He also realized after we recorded that there was a bit of information he hadn’t taught us which was crucial to being able to complete the challenge he had set for us. If you understood PBS 150 the first time through and want to jump right to the new part, I put a chapter mark in the audio file that will take you to where he explains /dev/tty.

We’re proud to have done this because we are both of the same mind that we need to stay committed to the quality of what we’re creating here, both for the current listeners and the future learners.


Bart and I took a few minutes upfront to high-five each other for 150 episodes of the Programming By Stealth Podcast. Then we quickly got to work.

Back in the Taming the Terminal podcast (at ttt.bartificer.net/…, Bart taught us about stream redirection, or what he likes to call Terminal Plumbing. This was a long time ago and many folks may not have listened to that great series. Bart takes us through it again but from the perspective of writing Bash scripts that can do everything we can do in the Terminal. We learn about Standard Input (STDIN), Standard Output (STDOUT), and Standard Error (STDERR). We also learn how to bifurcate STDOUT and STDERR to produce desired results. He walks us through how to use the symbols >, <, and our friend the pipe | to redirect output from commands and files. I did get stuck for quite a while in a few spots here and there. Bart continues to try to convince me that if I’m confused, at least one other learner is as well, so hopefully making Bart find different ways to explain these things to help me will help you.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_05_13

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #765 — Bart Busschots on PBS 149 of X — Better Arguments with POSIX Special Variables and Options (4/16/2023) by podfeet

In this rather mind-bendy episode of Programming By Stealth, Bart Busschots takes into the weird world of POSIX special variables and options. He refers to some of them as being like handling nuclear power, at one point he suggests mind-altering drugs must have been involved in the design, and he even compares one of our newly learned tools to a chainsaw.

He powered us through amidst my many interruptions with questions to where we can now write shell scripts that take flags and optional arguments using getopts. The final form of the syntax is very readable but knowing the reasons behind each bit is crucially important.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_04_15

CCATP #763 — Bart Busschots on PBS 148 – A Bash Potpourri (Subshells, Relative Paths & More) (3/25/2023) by podfeet

This week’s Programming By Stealth is a great lesson on how no matter how long you’ve been coding, you’ll still get caught out from time to time and think that the universe makes no sense. When Bart was working on the challenge from PBS 147, he ran into a bizarre situation for many hours. He eventually figured out what was going on, but it changed this installment into a walk down what went wrong, what he learned, and gave him the opportunity to teach us even more about shell scripting.

The entire installment is all about the solutions to the challenge from PBS 147 so you might want to take a shot at it yourself before listening to or reading this week’s installment.

Before we get started, I also explained how we now have a terrific way to share our work on the challenges, through a GitHub Organization called pbs-students. I wrote it up in the article entitled Introducing the Programming By Stealth Student Organization in GitHub

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_03_25

Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It’s by invitation only but all you have to do is ask Allison!

CCATP #762 — Bart Busschots on PBS #147 – Bash Arrays (3/18/2023) by podfeet

In this week’s episode of Programming By Stealth, Bart walks us through how to create, add to, and extract from arrays using Bash. It’s a very light episode, which I manage to drag out longer by making him slow down and dig into the syntax used for arrays. It’s not just me being dense (this time), there are squirrely brackets, square brackets, single quotes, double quotes, and the good old octothorp thrown in for some extra fun.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_03_18

CCATP #761 — Bart Busschots on PBS 146 of X – Shell Loops (3/4/2023) by podfeet

As Bart continues our education in shell scripting, he explains the simplicity of looping. He explains the four types of loops: while, until, for, and select, along with the simple syntax of do/done within a loop. He walks us through a lot of examples that illustrate how each one of these loops work. He ends by giving us a challenge, because teacher’s pet Allison asked for homework last time.

Enjoy this episode along with Bart’s fabulous tutorial shownotes at pbs.bartificer.net.

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_03_04

CCATP #759 — Bart Busschots on PBS 145 of X — Shell Conditionals (2/18/2023) by podfeet

Bart continues his miniseries on shell scripting by teaching us conditionals in the shell. In order to explain why conditionals are a bit odd in shell scripting, Bart first walks us through how it was originally done and then shows us the evolution to a much better method. It’s still weird, and many things are opposite of what you’d expect (like how 4 is actually > 10), but he gets us there in the end. I was most excited to finally learn what fi means, which shows up in shell scripting and I’d seen before in AppleScript.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_02_18

CCATP #758 – Bart Busschots on Programming By Stealth 144 (2/4/2023) by podfeet

This week our guest is Bart Busschots with Programming By Stealth 144. When last we recorded, Bart started teaching us the basics of shell scripting using Bash. We learned how to collect terminal commands into a reusable shell script, but we didn’t learn how to accept any kind of input.

In this installment, we learn how to take inputs either from the execution of the command or from user input and how variable names are created for the different ways of receiving input. We also learn about Exit Codes, which are really error codes, and how they can be used in boolean logic.

This knowledge will come into play when we learn next time about how to do conditionals and loops. It’s a short episode, and as Bart says, “not a heavy lift.”

mp3 download

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

Read an unedited, auto-generated transcript: CCATP_2023_02_04

CCATP #757 Bart Busschots on PBS 143 — Shell Script Basics (1/7/2023) by podfeet

In this week’s episode of Programming By Stealth, Bart Busschots starts building out one more tool in our toolbox: shell scripts. Bart starts with the basics explaining how to tell our little scripts which shell to run using the shebang line, the structure of shell scripts, commenting, assigning, and using variables, and how to write strings without having to escape every space and unusual character.

Throughout the installment, Bart refers back to things we learned in Taming the Terminal podcast and tutorial. If you haven’t listened to or read this series, you can download the book Helma helped us to produce using the Apple Books Store, or access it in a beautiful HTML version at ttt.bartificer.net/…, both of which have the audio of the podcast embedded within. You can find even more formats at podfeet.com/tttbook.

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

mp3 download

Read an unedited, auto-generated transcript: CCATP_2023_01_07

CCATP #755 — Bart Busschots on PBS 142 — The XKPasswdJS Project Kickoff! (12/10/2022) by podfeet

In this week’s installment of Programming By Stealth, Bart officially kicks off the XKPasswdJS project. This is what we’ve all been waiting for! As I said to Bart at the end of our recording, we’re no longer fixing to make a plan, we have a plan. The shownotes for this episode point to the README file for the GitHub project.

Bart explains n the podcast that we’ll have a project skeleton phase where Bart will define the code that has to be ported from Perl to JavaScript, and he’ll build the guidelines that will help us work as a team of contributors. This means things like a style guide, automated scripts to build the project, and configuration files for the tooling.

He has a vision that we’ll work on the direct port next, with no enhancements and I tried to get him to take a dollar bet on whether that goal will be achieved, but he didn’t fall for it. After that, we’ll go into maintenance mode.

It’s a fun episode because we’re finally moving forward after learning all of the tools we’ll need to make the project a success!

You can find Bart’s shownotes that point to the README at pbs.bartificer.net.

mp3 download

Read an unedited, auto-generated transcript: CCATP_2022_12_10

CCATP #752 — Bart Busschots on PBS 141 — Generating UML Class Diagrams with Mermaid (Don’t Cuddle the Mermaid) (11/26/2022) by podfeet

In the last installment of Programming By Stealth, Bart taught us all about UML class diagrams for documenting the structure of our code. In this installment, Bart teaches us how to use the ASCII diagramming tool Mermaid to make our class diagrams. The advantage of Mermaid over a graphical tool to make our diagrams is that we’ll be able to use Git to do version control for them. I think the most important part of this installment was when we learned that we shouldn’t ever cuddle the mermaid.

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

mp3 download

CCATP #751 — Bart Busschots on PBS 140 of X — UML Class Diagrams (11/12/2022) by podfeet

Bart and I are back from summer vacation to kick back into gear on Programming By Stealth. As you may remember, we’ve been learning all of the tools we’ll need to rewrite, test, and document Bart’s password generation library xkpasswd from perl to JavaScript. In order to start the rewrite, we need to understand the structure of the code we’re going to write, and instead of writing up a long text requirements document, we’re going to use a standard software diagramming language called UML Diagrams. In particular, we’re going to be using UML Class Diagrams.

Bart will probably do most of the diagramming himself as he dusts off decades-old code but we need to learn how to read UML Class Diagrams ourselves, so it will be another tool in our toolbelt.

Most podcasts would stick to everyday examples, but not here at the Podfeet Podcasts. Instead, Bart will teach us some Particle Physics along the way and you get that for free with this installment of Programming By Stealth.

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

mp3 download

CCATP #743 – Bart Busschots on PBS Tidbit 6 of Y — A Real-World Webpack Case Study (9/17/2022) by podfeet

In the past few episodes of Programming By Stealth, Bart has been walking us through worked examples to demonstrate how to roll up a web app using Webpack. These worked examples have been contrived to show how to perform the task.

This week in a Tidbit episode, Bart walks us through how he tried using the skills he’s been teaching us to roll up his this-ti.me web app. It’s a real-world test of the technologies and it allowed him to describe some of the pitfalls he fell into (though they were few and far between). It also gave him a chance to exercise the Webpack documentation, which happily turned out to be very good.

There’s no heavy lifting in this episode and no work to do to follow along. Instead, sit back and relax while you listen to Bart give advice on how to approach this task in your own code.

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

mp3 download

CCATP #742 – Bart Busschots on PBS 139 of X — Bundling a Web App/Site with Webpack (Part 2) (9/4/2022) by podfeet

In our last installment of Programming By Stealth, Bart started teaching us how to bundle an app/website using our bundler of choice, Webpack. The app/website he’s creating for us is very simplified but is intended to allow us to exercise every one of the kinds of things we’d want to bundle. This week we finish all of the tools he wanted to teach us to bundle.

In PBS 138, after explaining to us why we would want to do this, and initializing things, he taught us to import a pure JavaScript library with jQuery as an example, and a pure CSS library with basic Bootstrap as the example.

In this week’s show, we learn how to install and use Mustache for templating in a Webpack world. The process is quite a bit different from how we originally learned to implement Mustache in Programming By Stealth.

Then we learn how Bootstrap 5 now lets us import just what we need (instead of all of Bootstrap). We need some fancy icons so Bart teaches us about Bootstrap icons which he now favors for free icons over Font Awesome. Our web app wouldn’t be complete if we didn’t have a fun font, so we learn to import free web fonts from Fontsource all with Webpack.

Like the first half of the Webpack worked example, Bart’s process of doing repetitive actions but for different reasons definitely helped cement the concepts for me.

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

mp3 download

CCATP #738 – Bart Busschots on PBS 138 – Bundling a Web App/Site with Webpack (Part 1) (8/4/2022) by podfeet

We’re back in the saddle after a summer of “PBS Adjacent” installments. Our last real PBS was learning how to use Webpack to bundle a JavaScript library for sharing with the world. That was cool, but a lot of us want to use Webpack to bundle a web app we’ve written ourselves to include all of the libraries we’re using. We also want to have an easier way to reduce dependency on having an Internet connection. We also want an easier way to keep our bundle of libraries up to date. In this installment, Bart teaches us how to do all that with NPM and Webpack. I really enjoyed this episode because he used a worked example to show us how it all works, rather than talking only about the theory. The repetitive steps for each library really helped me to understand the process.

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

mp3 download

CCATP #736 – Bart Busschots on PBS Tidbit 5 of Y — Tips for the Vacationing Programmer (7/10/2022) by podfeet

I’m about to go on vacation where I suspect I’ll have little to no Internet to play with. It would be really cool if I could use any downtime (like on the 11-hour plane flight) to do some programming. Unfortunately, our code is often filled with references to content delivery networks to get needed libraries like jQuery and Bootstrap. While on my walk on Friday I was mentally preparing a post for our PBS Slack community to ask them how I can modify my code so that it doesn’t require the Internet to function.

Imagine my surprise and delight when I saw Bart’s topic for this week’s Programming By Stealth – it’s all about how to do exactly what I wanted. He covers how to prepare your computer for departure, how it’s important to clone any repos you might want to reference, and most importantly how to localize your dependencies and then what to undo when you return home.

It was exactly everything I needed to know and I hope it helps you too whenever you disconnect from the Net but still want to play with your code.

You can read Bart’s fabulous shownotes for this installment at pbs.bartificer.net/…

mp3 download

CCATP #724 – Bart Busschots on PBS 137 of X — Bundling a Library with Webpack (4/17/2022) by podfeet

We have one more thing to learn as we gear up to actually start writing modern code for Bart’s HSXKPasswd tool. The last piece of our tool kit is a bundler. In this installment, Bart teaches what problems bundlers solve, and he explains why he chose the bundler Webpack for our project. After learning about Webpack, Bart takes us through a worked example, bundling the Joiner module we’ve been working on through this part of the series. When we’re done, we’ll have an ES6 bundle and a Universal Module Defnition (UMD) bundle to cover both modern and more legacy needs. In the episode, you’ll hear me say that the exercise hit errors, and after the show, we diagnosed the problem and fixed the shownotes so have no worries about that!

You can, as always, find Bart’s fabulous show note tutorial for this installment at pbs.bartificer.net/…

mp3 download

CCATP #721 – Bart Busschots on PBS Tibit 4 of Y — Rethinking a Web App – from Web Server to Cloud Stack (3/31/2022) by podfeet

Over the past few months, podfeet.com went through a period of really poor performance. My site hadn’t been snappy in the last few years with page loads of up to 6 seconds, but it hit a tipping point where it was taking in excess of 40 seconds for pages to load. William Reveal and Bart migrated the services behind podfeet.com that improved performance to where most pages load in less than a quarter of a second.

In this Programming By Stealth adjacent episode, Bart wanted to walk through the structure of what makes up a web server, what a web server does, what all of the components are, and then walk us through how these things have changed in the nearly 17 years podfeet.com has been around. As we continue our journey in Programming By Stealth we are moving from the client-side to the server-side, so this lesson is quite relevant to helping our fellow learners understand what’s behind the next steps we’ll be taking.

There’s no homework in this episode but it’s also challenging to keep the pieces straight in your head so get ready for a fun and instructive “Tidbit”.

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

mp3 download

CCATP #719 – Bart Busschots on PBS Tidbits 3 of Y (3/19/2022) by podfeet

In this Programming By Stealth adjacent installment labeled Tidbits 3 of Y, Bart Busschots talks to us about the dangers of using other people’s code in your code, and the danger of not using other people’s code. He explains this seeming dichotomy and gives us ways to approach the problem taking a middle ground. He helps us think about how to choose whether to use other’s code and whose code to use, and even how to ensure it’s kept up to date with security patches. It’s definitely a philosophical installment and it was triggered by a recent event where a developer maliciously broke his own code, impacting a lot of developers. It’s actually sort of a success story of open source which I didn’t expect.

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

mp3 download

CCATP #717 – Bart Busschots on PBS 136 of X — More Jesting (3/5/2022) by podfeet

Bart Busschots taught us the basics of Jest last time for our Test Driven Development environment. This week we learn to group our tests using the describe() function in Jest. Grouping tests with describe does more than eliminate the need to comment our code, it also provides more useful output from our tests and scopes what happens inside.

As Bart describes it, we climb “Mount Jest” at one point as he explains how we can also loop our tests (instead of repeating code as we did last time) using describe.each()(). It’s a little head bending with arrays of arrays and functions of functions but it sounds worse to describe than it actually is to read and create.

He then describes ways to run certain setup and tear down functions before and after our tests are run and why we might need to do that.

Finally, we get the last cool thing we’ll need to understand about Jest, and that’s how to use the .only and .skip modifiers on our tests so that we can focus on individual tests while we’re chasing bugs.

For the first time in a long time, he even gives us an optional challenge to flex these new Jest muscles.

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

mp3 download

CCATP #715 – Bart Busschots on PBS 135 of X – Introducing Jest (and re-Introducing Test Driven Development & Unit Testing) (2/19/2022) by podfeet

In this week’s installment of Programming By Stealth, Bart takes us down memory lane to 102 episodes ago when he first introduced us to the concept of test-driven development. He explains why back then he taught us how to use QUnit for our TDD work, and why it’s no longer in favor with him. It’s not just the advancements in technology like ES6, but it’s also because QUnit makes it terribly hard to write tests and to interpret what you’ve written when you’ve been away from it for a while. He walks us through his criteria for picking a new TDD tool, and why he chose Jest for the job.

He then walks us through a worked example of how to write some simple tests on a module and of course, explains how Jest does its job running our tests. I liked it, even though my head hurt during a bit of it!

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

mp3 download

CCATP #714 – Bart Busschots – PBS Tibit2 – It’s Ok to Play a Different Game! (2/7/2022) by podfeet

This episode of Chit Chat Across the Pond perfectly straddles the line between Programming By Stealth and Lite. While it’s definitely a nerdy discussion topic, Bart Busschots is really just telling a story. He starts by explaining how he ended up a computer scientist essentially by accident, and tells us about a fantastic CS professor he had who inspired him through an assignment about a game called 8 Queens. He tells these stories as a way to explain that when I used the Terminal and egrep to help me solve the game Wordle a few weeks ago, it wasn’t really cheating. I think whether you’re a programmer or not, you’ll enjoy hearing Bart explain why.

Bart’s shownotes can be found at pbs.bartificer.net/…

mp3 download

CCATP #713 – Bart Busschots on PBS 134 of X — Firming up our Foundations (2 of 2) (1/22/2022) by podfeet

In this installment of Programming By Stealth, Bart Busschots finishes firming up our foundation on a few more things before we meet Jest, which will be the Test Driven Development (TDD) environment we’ll be learning next time.

He explains in some adorable examples involving a parrot (named Polly of course) how getters can be used to construct short but powerful syntaxes that seem quite counterintuitive at first glance. These are heavily used by Jest, and without learning about them, they would simply look like magic. He said some purists may see this syntax as an abuse of getters but it’s a pretty slick method that yields very readable APIs.

The second thing he teaches us is that functions can actually return functions. That sounds like opening a hole in the space-time continuum but it’s actually quite logical and useful as Bart explains the usefulness of this really well. No parrots involved, but lots of pancakes and waffles in his examples.

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

mp3 download

CCATP #711 – Bart Busschots on PBS 133 of X – Firming up our Foundations (1 of 2) (1/10/2022) by podfeet

In this installment of Programming By Stealth, Bart Busschots takes us through some review in order to prepare us to begin our journey into test driven development (TDD) with the tool Jest which he’s chosen for our TDD. He clears up some confusion on the difference between npm install and npm ci, and then he gives us more guidance on when to use which JSDoc tags, especially when documenting plain objects. He gives us a refresher on the different ways of defining functions, and especially arrow functions which are heavily used by Jest. Jest also uses function chaining heavily so he reminds us of how that works as well.

Even if you remember all of this and had it all clear in your head (I most definitely did not) it’s great to have all of this content in one post as reference.

The next installment will continue firming up our foundation with some new concepts that are heavily used by Jest.

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

mp3 download

CCATP #710 – Bart Busschots on PBS 132 of X — Managing JSDoc (12/21/2021) by podfeet

In this final Programming By Stealth and final Chit Chat Across the Pond for 2021, Bart teaches us how to manage our documentation in JSDoc. As any good programmer, he insists on automating as much as he possibly can. He starts by showing us each step that we have to do at the command line, and methodically puts together a JSDoc configuration file that runs scripts and helps create documentation directories, and installs plugins.

Even better he helps us to configure JSDoc so that it will alert us if we make a mistake in our inline or block tags, since JSDoc by default just ignores those mistakes. Finally we walk through three different themes for our documentation and we actually choose one for the XKPASSWD project and he shows us how we can even modify the theme. It all has to do with Bart preferring blue over purple.

It’s great fun, and really gives us the tool we need now to get ready for the next step. You can follow along with Bart’s fabulous tutorial show notes pbs.bartificer.net.

mp3 download

CCATP #708 – Bart Busschots on PBS 131 – Introducing JSDoc (12/13/2021) by podfeet

This week’s Chit Chat Across the Pond is another installment of Programming By Stealth with Bart Busschots. In our last installment, Bart explained why good documentation matters to ourselves and to other developers who want to use our code, and he also explained that using an automatic document generator like JSDoc could help make it easier for us to write good documentation and to keep it up to date more easily.

In this week’s installment, he starts to show us how to actually write JSDoc comments in line with our code. He explains the different elements of JSDoc comments and demonstrates how his own doc comments evolve as he figures out what he’s trying to do. I really enjoyed this installment and his example is perfect for us nerds.

I highly recommend you follow along in Bart’s fabulous tutorial shownotes at pbs.bartificer.net

mp3 download

CCATP #706 – Bart Busschots on PBS 130 of X – Good Technical Documentation (11/27/2021) by podfeet

As we embark on our journey to create a JavaScript module for the strong, memorable password generating service XKPASSWD, Bart explains the importance of creating good documentation. That sounds super annoying and tedious, and it is, so Bart explains why a good documentation generator will be our friend. He outlines the two distinctly different users of our documentation: those of us who will be helping to create the code itself as part of the community project, but also for the people who will be users of our JavaScript module. Those users will be interested in how to take the module and embed it into a web page to generate passwords, or to create an Alfred scheme and more. These two different users will have different requirements, and yet our documentation generator can fill both needs without unnecessary extra work. This isn’t the sexiest topic, but Bart does convince me that the tools will help us to have the rigor to do it and not let our human instincts take over and allow our documentation to get out of date.

You can find Bart’s fabulous shownotes at pbs.bartificer.net

mp3 download

CCATP #705 – PBS 129 of X – ESLint with Guest Instructor Helma Van der Linden (11/14/2021) by podfeet

Bart Busschots had a vision that certain things we would learn in Phase 2 of Programming By Stealth would be taught by guest lecturers. I thought he was bananas that this would work, but Helma Van der Linden, also known as Helma from the Netherlands stepped up to teach us about coding linters, and specifically ESLint.

In this installment she explains what linters are, and why they’re useful. Even though she’s not technically fond of them, she believes in linters because of what they can do for a coding team. Once she sells that idea, she walks us through how to install ESLint inside the development environment VSCode. From there she explains style guides, and shows us how to install and use the very popular airbnb style guide. She gives us tips on usage and even how to override the linter’s demands.

I think it was incredibly courageous to fill Bart’s shoes, and she did a fantastic job both in the podcast and in the detailed written show notes over at bartificer.net

mp3 download

CCATP #703 – Bart Busschots on PBS 128 of X – JavaScript Module Basics (11/2/2021) by podfeet

This installment of Programming By Stealth could probably have been two segments but all of us are itching to get moving quickly so we decided to power through. In the first part of the installment, Bart introduces us to JavaScript modules by giving us a bit of a history lesson on how they’ve evolved. If you’re brand new to modules, this will be interesting but not essential. If you have history with them though, you’ll definitely need to pay close attention to understand what’s changed.

Then Bart gets into the details of how modules work. He explains how JavaScript modules export variables, functions, and classes and how there are named exports and default exports and how the syntax differs. What fun would learning about exports be if he didn’t tell us how to import variables, functions and classes into our code for when we use these modules? We also learn about module specifiers to make it all go.

Finally, Bart takes us through three worked examples where he creates some JavaScript modules that exercise everything we just learned.

It’s a long episode but as always, Bart’s excellent show notes at pbs.bartificer.net

mp3 download

CCATP #701 – Bart Busschots on PBS 127 of X – Introducing NPM (and Node) (10/16/2021) by podfeet

As we launch full steam into Phase 2 of Programming By Stealth, Bart Busschots introduces us to the Node Package Manager and Node itself. Unlike our mini-series within a series for Git and Chezmoi, Bart isn’t going to do an exhaustive walk through NPM and Node. Instead he’s going to teach use what we need as we go along. In order for that to make any sense at all, in this installment, he explain to us at a high level Node and NPM are, and what problems they solve.

This lesson isn’t all theory though, we actually get to use Node and NPM to build a tiny, self-contained JavaScript app. I had great fun in this installment and Bart’s always fabulous tutorial shownotes are particularly well-written this time. You can find them over at pbs.bartificer.net/…

mp3 download

CCATP #700 – Bart Busschots on PBS 126 of X – Introducing Phase 2 (10/3/2021) by podfeet

At episode 700! of Chit Chat Across the Pond we take Programming By Stealth into what Bart is calling Phase 2. We’ve learned a great deal about the client side of programming and we’re now going to move to the server side of the web. As Bart described Phase 2, I realized that it’s as though we’ve finished out undergraduate work in computer science, and we’re entering graduate school.

That observation is not based on the concepts being harder, but rather because we are going to work as a collective to help our professor on a project that’s near and dear to his heart. Bart created the fabulous web-based password creation tool at xkpasswd.net many years ago, in fact so long ago that it’s on a very creaky set of tools that have been deprecated and the entire service will die if it doesn’t move onto modern tools.

This will be a great excuse for us to learn to work on the new tools as Bart is forced to learn them and at the same time we will be enlisted to help him with the development of the new and improved xkpasswd.

I was really excited as I listened to Bart lay out the future of the next 100 or so episodes and everything we’re going to learn. Whether you’ve been working alongside the rest of the listeners since Programming By Stealth 1, or whether you’re a seasoned programmer who’d like to learn the new tools like Bootstrap 5 and PHP 8, I think you’ll have great fun with the next phase of Programming By Stealth.

You can find Bart’s strategic plan for Phase 2 laid out at bartificer.net

mp3 download

CCATP #699 – Bart Busschots on PBS 125 of X – Chezmoi on Multiple Computers (9/18/2021) by podfeet

In this final episode of Programming By Stealth before we launch into the back end of web development with PHP, Bart finishes his miniseries on Chezmoi to manage dot files. In this installment he teaches us how to effectively manage our dot files on multiple computers using templating to ensure that the correct settings end up on every computer.

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

mp3 download

CCATP #698 – Bart Busschots on PBS 124 of X – Chezmoi Templates (9/4/2021) by podfeet

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

mp3 download

CCATP #696 – Bart Busschots on PBS 123 of X — Backing up and Syncing Dot Files with Chezmoi (8/22/2021) by podfeet

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

mp3 download

CCATP #695 – Bart Busschots on PBS 122 – Managing Dot Files with Chezmoi (8/8/2021) by podfeet

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

mp3 download

CCATP #693 – Bart Busschots on PBS 121 of X — Managing Dot Files and an Introduction to Chezmoi (7/23/2021) by podfeet

As we’ve become nerdier while learning from Bart, we have 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.”

mp3 download

CCATP #692 – Bart Busschots on PBS 120 – Ignoring Files in Git (7/10/2021) by podfeet

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

mp3 download

CCATP #690 – Bart Busschots on PBS 119 of X — Open Source on GitHub (6/27/2021) by podfeet

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 the 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 available at pbs.bartificer.net/…

mp3 download

CCATP #688 – Bart Busschots on PBS 118 of X — JavaScript Apps with GitHub Pages (6/12/2021) by podfeet

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

mp3 download

CCATP #686 – Bart Busschots on PBS #117 of X – Introducing GitHub (5/29/2021) by podfeet

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 why 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, edit the files, 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/…

mp3 download

CCATP #685 – Bart Busschots on PBS 116 0f X – Team Git (5/15/2021) by podfeet

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

mp3 download

CCATP #684 – Bart Busschots on PBS #115 of X – The Push & Pull of Git (5/1/2021) by podfeet

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

mp3 download

CCATP #681 – Bart Busschots on PBS 114 – Tracking Git Branches (4/17/2021) by podfeet

We continue on our journey to learn how to use Git to do version control as a single person, but this time with multiple devices. As Bart says during this episode, “Who is learning to program here who doesn’t have multiple computers?” We’ve learned how to push our changes to a single separate repo, but we had to always say what branch we wanted to push to what branch on the origin. In this installment, we learn how to tell Git to track our branches so they stay in sync without us having to tell Git every time which branches to push where. We also learn how to make sure our annotated tags get pushed as well by setting a single repo or all Git repos on our computers to push our tags. Bart leaves us with a big tease at the end. We learn how to clone a repo in preparation for having two computers accessing the same code in Git with a primary source acting as the go-between for them.

mp3 download

CCATP #679 – Bart Busschots on PBS 113 of X My First Git Remote (4/3/2021) by podfeet

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

mp3 download

CCATP #677 – Bart Busschots on PBS 112 of X – Introducing Git Remotes (3/21/2021) by podfeet

In this next installment in our mini-series on learning Git, Bart Busschots gives us some foundational knowledge on how to work beyond being one person with one Git repository.

He starts by reinforcing what he’s explained before, that Git is a peer-to-peer technology, which is hard to wrap your head around if you’re used to client-server relationships. He walks us through three scenarios to explain how every “actor” gets a repository and why. Then he explains the jargon of “local” vs “remotes”. It’s at this point that my head started to hurt, but Bart claims this is where I’m value-added to the podcast. I ask all the questions you might have, and I suspect many more than you have. Bart sticks with me and makes sure I fully understand.

You can find Bart’s tutorial show notes at: pbs.bartificer.net.

mp3 download

CCATP #669 – Bart Busschots on PBS 111 of X – Stashing Changes (1/31/2021) by podfeet

In this installment of Programming By Stealth, Bart teaches us how Git can help us when we forget to switch to the correct branch before starting to make changes to our code. We’re only human, and we will forget, and Git’s stash command allows us to set our changes aside, switch to or even create and switch to the correct branch and then apply our changes. His explanations and repetition in the exercises really cement the knowledge. As a bonus tip, he teaches us how to make shell variables inside the Terminal which will help us with some of the repetitive typing in the future.

Bart’s tutorial shownotes are at pbs.bartificer.net/pbs111

mp3 download

CCATP #668 – Bart Busschots on PBS 110 of X – Merge Conflicts (1/16/2021) by podfeet

In this installment of Programming By Stealth Bart teaches us how to deal with conflicts in branches of our code. He has been purposely only changing one thing at a time before now, but it’s time to face the reality of when two branches change the same line in the same file. I’ve been terrified of this topic for a long time, but Bart shows us how easy it is to see exactly what the conflict is, how you can back out of merging if you make “a pig’s breakfast” of it, and how to resolve your conflicts without fear. It’s not nearly as terrifying as I thought it would be.

You can find Bart’s tutorial show notes at pbs.bartificer.net/…

And if you learn a lot from Bart, please consider becoming a patron of his by going to www.patreon.com/…

mp3 download

CCATP #666 – Bart Busschots on PBS 109 of X — SemVar & Structured Commits (12/29/2020) by podfeet

We continue our mini-series within a series learning the version control system Git. We learn two methods to enhance our branching strategy. First, we’ll walk through some basic principles on how to number our released versions of our code. From there we’ll explore three types of changes that would cause a change in our release version: fixes, new features, and breaking changes. Each of these types of updates to the version of our code can be articulated with Semantic Versioning, also known as SemVer. This numbering convention informs users of our code on the meaning of each release. Finally, we marry these concepts by creating meaningful commit messages using another convention called Conventional Commits. Not only can a user of our code see at a glance what happened in a specific commit, documentation can be auto-formatted to explain the commits.

There’s not a lot of hands-on in this lesson but as a structured person, I really appreciate these conventions and why they’re important.

You can find Bart’s tutorial shownotes at pbs.bartificer.net/…

mp3 download

CCATP #665 – Bart Busschots on PBS 108 of X — Merging & Tagging (12/18/2020) by podfeet

In this installment of Programming By Stealth, Bart Busschots continues on his series within a series explaining the version control system Git. We advance in our branching strategy by working several commits on our dev branch and then learn to use a merge commit to bring only the final commit into the main branch, leaving the half-working intermediate commits to exist only on the dev branch. This process illustrates the need to learn about tags, both light-weight and annotated. Once we understand how these tags work and their importance, we evolve our PBS branching strategy one step further.

Bart’s tutorial shownotes are available at pbs.bartificer.net/…

mp3 download

CCATP #663 – Bart Busschots on PBS 107 of X – Branching Basics (12/2/2020) by podfeet

This week in our miniseries on learning the version control system Git, Bart dips our proverbial toe into branching. Branches allow us, as developers, to work on bugs or feature enhancements in a separate place from our stable code, and only merge the code back in when the bugs are squashed or the features are stable.

We don’t get much practice in this instalment, but rather Bart talks to us about the idea of having a strategy for when to branch and how to name your branches in order to prevent chaos. He gives us some simple and yet difficult to adhere to strategies and then takes us through more rigorous strategies that will actually be easier to follow. He emphasizes that he’s not telling us which strategy to follow, but rather to have a strategy.

We do a few small examples from the command line, but we get to open our Git GUI clients, like GitKraken and Sourcetree and see how the commands we’re typing are graphically represented in the clients. It’s a good illustration of what Bart has been promising us – that the GUI clients are doing exactly what the command line is doing.

You can find Bart’s tutorial shownotes at https://pbs.bartificer.net/pbs107. And if you’d like to support Bart on Patreon, go to patreon.com/ltpod.

mp3 download

CCATP #661 – Bart Busschots on PBS 106 of X — Time Travel with Git (11/20/2020) by podfeet

As we continue to learn Git from the command line for version control, Bart teaches us some tricks to travel through time. First he shows us how to view more compact Git logs so we can just see a shortened hash and the first line of our commit message. Then he shows us how to pick out a single commit from the past and see what changed. Then he shows us how, with surgical precision, we can go back in time and get a single file or even just the changes from a specific commit and bring them forward in time. It sounds head bendy but I could immediately see the usefulness of going back in time and grabbing some code that was working well and bringing it forward.

You can read Bart’s tutorial shownotes at pbs.bartificer.net/…

mp3 download

CCATP #659 – Bart Busschots on PBS 105 – Seeing the Past with Git (11/7/2020) by podfeet

In this installment of Programming By Stealth, Bart takes us on a time traveling adventure with Git. By using commands like git diff we can see changes over time, but we can actually see older versions of the code in a couple of ways. Using the archive command we learned out to pull just the files at a certain point in time (without the history) and the more terrifying checkout command that creates a “detached HEAD”! Bart even explains why that phrase was introduced and what it actually means. This was a fun lesson and a good foundation for what we’ll learn next time, when we’ll learn about stashing and branching to control the past and future.

Follow along with Bart’s tutorial shownotes at pbs.bartificer.net/…

mp3 download

CCATP #658 – Bart Busschots on PBS 104 – Tracking Changes in Git (10/24/2020) by podfeet

In our next baby step in learning to use the version control system Git, Bart teaches us how to track changes. We start by doing a bit of housekeeping, especially for Mac users to set Git to always ignore those pesky .DS_Store files. We learn how to stage and then commit a simple change, then we stage and commit multiple changes and even learn to see the differences in our staged files from the database all from the command line.

While we all think we’re capable of making one structural change and then committing our changes, Bart knows that it isn’t going to happen. But there’s still a way to follow Helma’s advice to “commit early and commit often”. Bart teaches us how to divide the changes we inevitably make into separate commits with separate comments so we can figure out what we did later.

I enjoyed this installment because I could tell it was laying a very important foundation of understanding. You can follow along with Bart’s famous shownotes at pbs.bartificer.net/…

mp3 download

CCATP #656 – Bart Busschots on PBS 103 of X — Getting Started With Git (10/11/2020) by podfeet

After some quick revision from the previous episode, Bart explains how Git commands work with their subcommands. We start by looking at how to configure Git and the differences between local, global and system-level settings. Then we create our very first repo with an exciting README file, and we commit the file to our repo. It’s a fairly simple lesson while laying down a good foundation for all future work.

You can find the shownotes for this installment at PBS 103 of X — Getting Started With Git

mp3 download

CCATP #654 – Bart Busschots on PBS 102 of X – Introducing Git (9/27/2020) by podfeet

In our last Programming By Stealth we learned about the concept of version control, and the evolution from client/server version control to peer-to-peer version control and the creation of Git. In this installment we start learning the fundamental concepts of Git. We learn about the database, the working copy, and the index and understanding the difference is critical to effectively using Git. We also dig into the Git database and begin to learn the terminology inside it, which oddly uses normal English words but those words might not mean what you think they mean. We gain an understanding of why Git uses SHA1 hashes but not for encryption. We start to get into the power of Git as we learn about commits, staging, stashes, and tags.

We didn’t get to play with Git yet but the challenge is to install Git and if you want the extra credit, choose and download one ore more Git GUI clients.

Bart’s tutorial show notes are at pbs.bartificer.net/…

mp3 download

CCATP #652 – Bart Busschots on PBS 101 – Introducing Version Control (9/12/2020) by podfeet

In this turning of the century episode of Programming By Stealth, it’s time to take on a new subject: version control. As Bart explains in this week’s episode, version control allows you make changes in your code and roll the changes back. This gives us the freedom to experiment and if an idea doesn’t pan out, get back to where we started. Bart explains some of the origins of version control, starting with client server systems and then tells us how peer-to-peer version control has become the standard from industry to open source.

Bart explains how the version control system Git was created and how it proved itself worthy of becoming the standard. There’s not a lot of heavy lifting in this episode but Bart promises that future episodes will be challenging as we get into how to actually use Git.

If you like Bart’s work, please support him by going to lets-talk.ie and becoming a Patron.

mp3 download

CCATP #651 – Bart Busschots on PBS 100 of X — Time Sharing Challenge Solution (8/30/2020) by podfeet

Bart and Allison holding up their cake100th Programming By StealthIn this positively delightful episode, Bart and I celebrate 100 episodes of Programming By Stealth. When we hit 99 installments, Bart declared that for 100, there should be cake! So I got Bart’s darling beloved to deliver him a piece of cake right as we started, and Steve delivered one to me. To say that Bart was surprised and delighted would be an understatement!

The actual episode was an opportunity for Bart and me to share our respective solutions to the challenge from PBS 96, which was to create a web app that would allow a podcaster to send a time of their choosing to another podcaster. He didn’t put a lot of restrictions around it, so our solutions are completely different.

I begged to go first because I told him that going after him is like being the comedian who had to go on after Robin Williams. He replied that he wanted to go first for the same reason! He explained that I took on a much harder task than he did. In his solution, he picks a time in his own timezone and then copies a URL from the site and sends it on to the other people and they see the time he chose in their own browser. He did add a few bells and whistles beyond that but it’s the basic idea.

My solution allows the user to enter two timezones of their choosing and then drag a slider to shift time to see how convenient it is for the other person, and then copy the time. I was quite pleased with my user interface, and Bart even borrowed one of my ideas to use a utility called Bootstrap Collapse to show and hide certain page elements. To be doing something that Bart wants to emulate warmed my little heart.

A fun fact about our solutions is that Bart worked on his for an entire 3 days, and I worked on mine for two months on and off. I’m still proud of what I accomplished!

You can read Bart’s and my tutorial shownotes for this episode by going to pbs.bartificer.net/… Thank you Bart for this amazing accomplishment.

mp3 download

PBS Listeners – Can We Interest You in a Cup of Taming the Terminal? (7/12/2020) by podfeet

Hi, Programming By Stealth listeners! I wanted to let you know that Bart and I are taking a bit of a break from Programming By Stealth, the need for which happens every summer but for some reason catches us both unawares each year. Bart works in education and the summertime is the only practical time to make huge changes to the computer systems underlying said education. As you might guess, this year presents even more “interesting” challenges.

However, Bart and I are not lying down on the job, and we have something to offer you while you await the next installment of Programming By Stealth.

Five years ago Bart and I started a series called Taming the Terminal which ran for 35 of n episodes. Like Programming By Stealth, he made the ending indeterminate. He did this because while he accomplished the teaching he set out to do, he knew that things would change in the macOS terminal and new advances would be the opportunity for new episodes.

After a year hiatus, he brought us episode 36 in late 2016 where he taught us about screen which allowed you to SSH into servers and start processes that would continue even while disconnected. In mid-2017 he taught us about SSH agents to address a change in El Capitan that made you have to enter your passphrase to a server more often. This affected what we were taught in TTT30 about SSHing into our servers.

It turns out that Red Hat deprecated screen recently and instead there’s a tool called tmux that does everything screen used to do and more.

This week Bart and I recorded installment 38 of n in which he taught us the basics of tmux that replace screen‘s functionality. And in two weeks we’re going to publish the second half of the tmux story where he will teach us the other cool stuff it can do.

If you are an avid listener to Programming By Stealth, then I’m sure that Taming the Terminal will be a fun podcast for you. You can easily jump in right now to episode 38 or you can start at episode 0 and listen to all the back catalog.

As always you can find Taming the Terminal in your podcatcher of choice, and this week’s episode is also included in the full Chit Chat Across the Pond feed.

Or you can listen to Taming the Terminal installment 38 of n right here:

mp3 download

CCATP #643 – Bart Busschots on PBS 99 of X – Building with Classes Part 2: Is-A (6/28/2020) by podfeet

This week Bart Busschots brings us the penultimate JavaScript installment of Programming By Stealth as he brings us part 2 of building with classes. This wraps up our third look at Object Oriented programming in JavaScript. We learn about the concept of inheritance, and how it allows us to build classes that inherit attributes and functions from parent classes. This allows us to eliminate code duplication which Bart explains is called a “bad smell”.

You can find Bart’s tutorial shownotes at pbs.bartificer.net/pbs99.

mp3 download

CCATP #642 –– Bart Busschots on PBS 98 — Building with Classes Part 1 — Has-A (6/13/2020) by podfeet

In this episode of Programming By Stealth, Bart explains one single concept, that of “Has-A”. This is part 1 of 2, where next time we’ll learn “Is-A” which is about inheritance. These both sound like odd terms but they’re part of what makes object oriented programming so powerful. Bart spends 90% of the time going through a worked example which not only explains how classes can have instances of other classes as properties, but also how classes can be more specific versions of other classes. Along the way, I think he achieved his goal of cementing the foundation of getters and setters and Class functions and Instance functions. We’ll see if I can use them in anger on the homework though!

You can find Bart’s tutorial shownotes at pbs.bartificer.net/…

mp3 download

CCATP #640 – Bart Busschots on PBS 97 — Class Data Attributes & Functions (5/31/2020) by podfeet

I’m not going to lie to you guys, this episode of Programming By Stealth was pretty rough for me. It builds on the foundation Bart laid in PBS 95 where he introduced Getters and Setters and it was pretty clear that this previous lesson had not sunk in for me yet. I’ll definitely have to go back and study PBS 95 a couple more times and get a chance to practice this Getter/Setter concept before the penny will drop. Hopefully you understood it better than I did the first time through!

In any case, in PBS 97, we extend that knowledge to learning about class data attributes and functions. We’ll learn the “static” nomenclature, which is used to mark attributes and functions as belonging to the class rather than the instances of a class.

Bart spends most of the lesson on a worked example using emoji to create what he playfully calls a Nerdtouche, as a head nod to the cartouche used by Egyptian Pharoahs. And yes, he manages to work the poop emoji into this lesson.

You can find Bart’s shownotes at pbs.bartificer.net/pbs97.

mp3 download

CCATP #638 – Bart Busschots on PBS 96 of X — World Clock Challenge Solution (5/16/2020) by podfeet

This installment of Programming By Stealth is a solutions show all about the clock assignment from PBS 92. Bart’s been quite busy this week designing an entirely new distance final exam system for the university where he works so he asked if I’d take on half of the content by presenting my solution to the clock challenge. I have had an absolute blast on this assignment so I gladly accepted. I walk through my approach and some of the challenges I met along the way, and then Bart complements mine by talking about a few things he did quite differently. We both had a great time and I think Bart even learned something from me at one point.

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

mp3 download

CCATP #637 — Bart Busschots on PBS 95 of X — Better JavaScript Class Attributes (5/2/2020) by podfeet

This week Bart explains how to give our JavaScript classes better data attributes via a very powerful JavaScript feature: getters and setters. On my first read through the notes for the episode, my head was spinning a bit, but Bart explains this so well using concrete examples (like a circle with a radius) that I think he got it through to me. When I told him up front that I struggled a bit when reading the shownotes, he said that this is the “pointy end” which I think meant that it was a difficult concept so I felt a little better about it.

In the end it made a lot of sense and I see the reason for the tools he explained.

I highly recommend you read Bart’s terrific tutorial shownotes at pbs.bartificer.net/pbs95 as you listen along.

mp3 download

CCATP #635 — Bart Busschots on PBS 94 of X — Basic JavaScript OO with Class (4/18/2020) by podfeet
Allison diagrams classes constructors and instances
My Diagram Explaining Classes, Constructors, Objects and Instances

In the early days of Programming By Stealth, Bart tried to explain JavaScript classes, objects and instances. He talked about it in Installment 17 before ES6, and then took another run at it in installments 27-31. But it never felt to Bart like he had explained it in a way that made it clear.

In installment 94, Bart finally nails it. I told him the shownotes for this installment might be the best he’s ever done. Everything he explains is clear and concise, the examples are superb, and we get to say Hoonyaker a lot. Instead of being frustrated and confused, I was smiling through all of it because I finally get it. I also told him that I feel far less stupid than I did before because I always thought it was my failing that I didn’t get it. I enjoyed this so much I drew Bart a picture of what he’d taught and he said I nailed it!

You can find these legendary shownotes at pbs.bartificer.net/pbs94.

mp3 download

CCATP #632 – Bart Busschots on PBS #93 – Encapsulation with JavaScript Objects (4/5/2020) by podfeet

In this episode of Programming By Stealth, Bart takes us through the last “hat” that JavaScript objects can wear: encapsulation. As Bart walks us through the problems encapsulation solves using a funny NosillaCast-specific example, he shows how the code becomes reusable and sharable with encapsulation, and even more readable.

You can read the tutorial shownotes as you listen at pbs.bartificer.net/…

mp3 download

CCATP #630 – Bart Busschots on PBS 92 — Currency Grid Solution (3/20/2020) by podfeet

CCATP #630 for March 14, 2020, and I’m your host, Allison Sheridan. This week our guest is Bart Busschots with PBS 92 of X in which he walks us through his solution to the assignment from PBS 89 to create a grid of currency conversions.

He doesn’t go through his code line by line, but rather gives us the big picture of his process. Most of the time he spent on the solution was actually in refactoring his code because he decided to preload the data rather than fetching it repeatedly on-demand. I loved it when he referred to his original work as “Organically-grown Weasley-kind of code”.

He also explains how he used both coercion and assertion to do his error handling and why. Eventually he got to start working on the grid and he walks us through how he cracked that problem. It was great fun as always and we have a new, six-week challenge to build a world clock.

You can find his full tutorial shownotes and download his solution at pbs.bartificer.net/pbs92

mp3 download

CCATP #628 — Bart Busschots on Creating Automator Quick Actions (3/7/2020) by podfeet

This week our guest is Bart Busschots with an installment of something he’s calling Programming By Stealth-adjacent. It’s not part of the regular series of Programming By Stealth, and yet it’s not technically very “light” in terms of the chit chatting. Since neither podcast is the right place for it, I’ve decided to put it in both podcast feeds to be wrong twice.

Bart walks us through how to create Quick Actions with Automator (also known as Services) to do some simple but very useful text manipulations using a smidge of JavaScript. Even if you don’t want to write these Quick Actions yourself, you can download his services from his Github repo where he’s put them up as open source: https://github.com/bbusschots/macos-quickaction-text.

You can see how Bart created this in his blog post at www.bartbusschots.ie/…

mp3 download

CCATP #626 — Bart Busschots on PBS 91 of X — JavaScript RE Objects (2/22/2020) by podfeet

Bart takes us through the penultimate hat JavaScript wears and that’s Regular Expressions. Luckily since we haven’t talked about REs in ages, he reminds us of the syntax for Regular Expressions literals in JavaScript first and then he takes us through three common uses for Regular Expressions. We joked around during this episode at how many times I said, “That makes sense!” Bart said it was music to his ears, and I say this was a very intuitive lesson considering how arcane Regular Expressions are in their syntax.

Bart’s tutorial for this episode are available at pbs.bartificer.net/…

mp3 download

CCATP #624 — Bart Busschots on PBS 90 of X — JavaScript Wrapper Objects (2/8/2020) by podfeet

Hope you enjoyed getting the little extra Tidbits episode this week. In this installment Bart continues our on-going mini-series looking at each of the proverbial hats JavaScript objects wear. Bart explains the concept of JavaScript wrapper objects that allow you to access properties of otherwise property-less primitives. It’s pretty magical and I only got lost for a little while as we brushed the cobwebs off my memories of prototypes and such.

Bart’s shownotes for this episode can be found at pbs.bartificer.net/pbs90.

mp3 download

PBS Tidbit 1 of Y — Display Values are not Data! (2/8/2020) by podfeet

This is not a normal episode of Programming By Stealth, it’s what Bart Busschots is calling a PBS Tidbit. Listener @lbutlr pointed out to Bart and me on Twitter that Bart’s math was wrong in his solution to the challenge he posted in PBS 89. The assignment was to produce currency exchange rates for a variety of currencies, based an amount for the base country. That is, 10,000 Japanese Yen is how many Euro, Canadian Dollars and New Zealand Dollars.

The problem was that if you chose large amounts (like 10,000 Yen), Bart’s math fell over in a heap, returning 100 for all countires or with South Korean Won, most countries returned 0.

Instead of being incensed or embarrassed at having made a mistake, Bart dug in, figured out what went wrong, and then wrote up his path to discovery and the tools he used to fix the mistake. He made it a teachable moment. He decided to call this PBS Tidbit 1 of Y because this probably won’t be the last time this happens.

After Bart finished, I talked about another thing @lbutlr told us and how I’m trying to implement it in my challenge solution. I’ll be writing that up once I get it figured out.

You can read Bart’s explanation at www.bartbusschots.ie/….

mp3 download

CCATP #622 — Bart Busschots on PBS 89 of X — Currency Converter Challenge (1/26/2020) by podfeet

In this week’s installment of Programming By Stealth, Bart explains his new plan for both the content of PBS and the way the shownotes are created and presented to you. Bart has noticed that because we put a challenge solution and new content into the same show, the solution gets short-changed. That’s a shame because there is so much he can teach by explaining the “whys” behind the design of his solutions.

The new plan is to have the challenge solutions be standalone shows, and then the new content will be standalone shows as well. We’ll be having more time to do our challenges with this new plan as well. I’m excited about this new plan because I’ve enjoyed the extra time we’ve had with our currency converter challenge, allowing us to enhance our solutions and be more creative.

This week’s installment then is a review of why he made certain decisions on how to solve the last Programming By Stealth challenge, which was to add the ability for the user of our currency exchange web app to enter a value to be converted to the different currencies.

Bart is also completely rearchitecting all of his web presence, including his Programming By Stealth show notes. His new online presence will be at his site, bartficier.net and PBS will now be at pbs.bartificer.net. That link is actually to a GitHub page. I know that sounds crazy and Bart is going to tell us more about it, but it will allow him time to be much more creative and spend less time faffing about as a system admin. This is very much a work in progress and we expect a few learning opportunities along the way!

With all that said, you can find the shownotes to this week’s installment at pbs.bartificer.net/…

mp3 download

CCATP #619 — Bart Busschots on PBS 88 of X — DOM & jQuery Objects Redux (12/14/2019) by podfeet

Bart is nearing the end of his mini-series recapping al of the different hats JavaScript objects wear, doing a lot of redux to cement the concepts that have been spread over so many lessons. He takes a really interesting approach this week to his teaching. He explains a concept and then instead of having a contrived example, he shows us exactly how that concept works in action in his homework solution from PBS 85. His solution to the homework assignment is, of course, beautiful and elegant. Beautiful he gives credit to Bootstrap, elegant he would probably give credit to jQuery.

I am really enjoying these redux segments because they cement things that were still wobbly, or perhaps even gone from my memory. Each time through I’m finding I understand how to even categorize the information in my brain. I explained to Bart that I think he’s actually changing the way my brain is wired now.

You can find Bart’s tutorial shownotes at pbs.bartificer.net/…

mp3 download

CCATP #617 – Bart Busschots on PBS 87 of X — JavaScript Iterators Objects & Generator Functions (11/30/2019) by podfeet

I’m not going to lie, this episode of Programming By Stealth with Bart Busschots was a bit head bendy. Bart explains JavaScript Iterator Objects and Generator functions but without his excellent examples I’m certain I would never have been able to get the concepts to even slightly congeal in my brain. Iterator Objects and Generator functions are some of the joys of ES6 and have great value.

That value is demonstrated in the succinctness of the code Bart writes for us to create a Fibonacci series in a beautiful web form. That work, by the way, is a bonus challenge if you’re done with your homework from the previous episodes. As you listen along, if you hear us yelling “spoiler alert” and making alarming noises, that’s when Bart’s solution to the challenge is about to be described. It’s a rare instance where I actually let you have one chapter mark in Programming By Stealth so you’ll be able to jump back to the solution after you’re done with your own solution.

Bart’s tutorial shownotes can be found at pbs.bartificer.net/…

mp3 download

CCATP #615 – PBS 86 of X — JavaScript Function Objects (Redux & Update) (11/14/2019) by podfeet

This week Bart Busschots takes us back through JavaScript function objects, explaining the three different ways to define a function. It was great to have them all together to refresh our memory. He explains how only one method is hoisted, which lead him to explain the medieval history reference of “hoisted by your own petard”. There was a part where he talks about wearing tutu, but Only a podcast with Bart could go that route! We went from there to function scope and enjoyed some time going through advanced arguments which is way more fun than it sounds. Things took a turn for the weird when Bart explained fully-simplified fat arrow syntax as all common language conventions disappeared. Also we talked about Bart wearing a tutu. You’ll have to listen to learn how that was actually in context.

mp3 download

CCATP #613 – Bart Busschots on PBS 85 of X — Objects as Arrays in JavaScript (Redux & Update) (11/3/2019) by podfeet

Bart continues his redux and new information by circling back through Objects as Arrays in JavaScript. I don’t know about you, but I get a lot out of the redux episodes because it cements in place concepts that were a bit wiggly before he goes through it again. The one new concept he goes through is Array Destructuring which sounds ominous and destructive but which allows us to dive into arrays and create new and more interesting arrays.

Bart also debuts a new way he’s providing the content for the lesson. If you still want to download the zip file with all of the example files, you can, but you can also view the source code and view the HTML in a browser with a Github link. By the way, the zip file is now living on a content delivery network. This is important to note if you’re coming in from Safari with the more recent security updates because it will prompt you to agree to downloads from this new URL.

Bart’s fabulous tutorial show notes (including the links to the source for this week’s episode) are available at pbs.bartificer.net/…

mp3 download

CCATP #611 – Bart Busschots on PBS 84 of X – Objects as Dictionaries in JavaScript (Redux & Update) (10/20/2019) by podfeet

Bart has been noticing that there are a few key features in JavaScript that haven’t ever really congealed for me and is circling back in hopes of firming them up. The other reason he’s going over these topics is that new options have been created since we first covered them. The first of these subjects is objects as dictionaries. I confessed to him recently that I’ve never successfully done a for loop on my own yet, so we slow down a bit during that part but we speed up again into what are actually more challenging topics. We had a lot of fun doing this episode (even when I was stuck!)

Bart’s tutorial shownotes can be found at pbs.bartificer.net/…

At the end of the show, I suggested a palate cleanser, which is a feature of his Security Bits segment he does for the NosillaCast. I found an awesome tweet by developer Sarah Dresner aka @sarah_edo: “Apparently the only cure for jetlag is to make SVG animations of farting rhinos with the new @greensock API 💨”. Of course I had to follow that link, and it was awesome. It is literally an SVG file of an adorable little rhino trotting along and tooting. After Bart and I got off the air we took advantage of the fact that she’d posted the farting rhino on codepen.io so we view the HTML, CSS, and JavaScript to see how she did it. I know this is silly but that’s what makes it so awesome.

mp3 download

CCATP #610 – Bart Busschots on PBS 83 of X Bootstrap Cards (10/4/2019) by podfeet

Bart finishes up our first exploration of Bootstrap 4 with a look at one its most versatile components, the so-called Card. This is one of those components that’s so generic it’s hard to describe, but once you learn about it you’ll start seeing it all over the web. Cards really are ubiquitous!

It’s important to stress that while we’re wrapping up our exploration of Bootstrap 4 with this installment, that does not mean we’ve come close to covering every feature this impressive library offers. Instead, the aim was to cover the big-picture items, and leave you with enough experience to be able to learn the rest independently by reading Bootstrap’s excellent documentation.

Bart’s tutorial show notes can be found at pbs.bartificer.net/…

mp3 download

CCATP #609 – Bart Busschots on PBS 82 of X – Async & Await (9/20/2019) by podfeet

A quick note here – Dorothy, aka @maclurker in our Slack group has been applying all of her newly-acquired programming skills from PBS to her fabulous PBS Index. She’s now using Mustache templates, Bootstrap styling utilities, and even AJAX with JSON. The result is a beautiful thing to behold, giving us immediate results as you start to search and more. Bart has now made a permanent URL for the PBS Index, it’s bartb.ie/pbsindex.

Since Bart works for a University, summers are not a time of rest and relaxation for the system admin staff, they’re the only time upgrades and maintenance can get done because the students are gone. In the future, we think we’ll plan our summer hiatus for Programming By Stealth rather than it taking us by surprise each year.

In any case, we’re back with a new installment where we attempt to dust off Allison’s brain and learn about two new promise-related keywords, async and await. Both of these keywords were actually added to the core JavaScript language, so this doesn’t happen that often.

With async and await, we can actually get away from doing promise chains and create much more readable code while still being able to control parallel and in series tasks. Bart had to drag me along a bit in this one but I saw the beauty of it when we were done.

Bart’s fabulous tutorial shownotes can be found at pbs.bartificer.net/…

mp3 download

CCATP #602 – Bart Busschots on PBS 81 of X – The JavaScript Promise Utilities (7/12/2019) by podfeet

In this installment of Programming By Stealth, Bart teaches us how to use Promises, with a capital P to get promises when we already know the value we want to supply. That sounds funny but it will make sense in context. Then he shows us how we can control parallelization of promises using Promise.all(). It’s a very sensible lesson, and not brain bendy at all. (I really like those.)

Please consider supporting Bart’s hard work for us via Patreon at patreon.com/ltpod

Bart’s fabulous tutorial shownotes are available at pbs.bartificer.net/…

mp3 download

CCATP #600 — PBS Supplemental — Dorothy Rendon on the PBS Index (6/25/2019) by podfeet

In the very first Programming By Stealth supplemental episode, I interview Dorothy Rendon, the programmer behind the PBS Index. If you haven’t seen it before, it’s an index that Dorothy has created for the Programming By Stealth students to helpt them find key topics in Bart Busschots’s fabulous tutorial shownotes.

We’ll first get a little background on Dorothy and then move on to learning how she used to produce the index, and how her advanced learning in Programming By Stealth allowed her to simplify the process and make it prettier, using JSON, Bootstrap and mustaches. I didn’t want to leave you without something in your Programming By Stealth feed while I’m on vacation and I think you’ll find it a lot of fun.

If you want to chat with Dorothy about the PBS Index, you can find her in the Podfeet slack at podfeet.com/slack under the handle @MacLurker.

mp3 download

(more…)

CCATP $#597 — Bart Busschots on PBS 80 of X — JavaScript Promise Chains (6/14/2019) by podfeet

Bart Busschots (successfully) explains the concept of JavaScript promise chains. It’s a rough ride because of the subject itself, but he gets us there through his care and detail in explaining the concepts and of course his great examples. When he’s done, you’ll know how to chain promises together, you’ll understand what data is passed through, and you’ll understand why he says, “Don’t have unhandled rejections, it’s just not nice.”

You can find Bart’s detailed shownotes at pbs.bartificer.net/…

mp3 download

CCATP #595 — Bart Busschots on PBS 79 — Introducing JavaScript Promises (5/31/2019) by podfeet

Bart has been promising us Promises for ages now and he finally fulfills his promise by explaining thenables. Promises are a tool to get us out of “callback hell”, which we experienced a while back. I think he made us suffer through that so we’d appreciate Promises. In this episode he shows us the beauty and elegance of the concept but leaves us wanting more. Bart spent a lot of time trying to get the shownotes and his narrative to take this rather abstract concept and make it concrete, and I think he did a grand job of it.

Bart’s amazing tutorial shownotes are available at pbs.bartificer.net/…

mp3 download

CCATP #593 — Bart Busschots on PBS 78 — is.js & Bootstrap Popovers (5/17/2019) by podfeet

Bart Busschots and I both had a great time doing the challenge this week. In this week’s installment Bart takes us through his homework not in a detailed step-by-step method, but rather he goes through some major structural ways he created his code. He digs deep enough to explain why but it’s a great lesson on building code that’s easier to debug and more fun to write. I got to be the tester of his code, and as I suggested improvements he decided he needed to use Bootstrap Popovers. He walks us through how they work and I have to say they’re really slick. Then he introduces us to a super intuitive JavaScript library called is.js that solves will simplify our code. I asked Bart if he could back up 2 weeks and show me is.js BEFORE I did last week’s homework!

As always, Bart’s awesome tutorial shownotes are available pbs.bartificer.net/…

mp3 download

(more…)

Scroll to top