Podcasts by Category
- 203 - PBS Tidbit 9 – Using Git on iOSThu, 10 Oct 2024
- 202 - PBS 171 of X: MVC in XKpasswd-jsSat, 28 Sep 2024
- 201 - PBS 170 of X: Model View Controller (MVC)Sat, 14 Sep 2024
- 200 - PBS Tidbit 8 – Interview with jq Maintainer Mattias WadmanTue, 06 Aug 2024
- 199 - PBS Tidbit 7 – jq to Analyze macOS Installed Apps with Helma van der Linden onSat, 20 Jul 2024
- 198 - PBS 169 of X — Advanced YAML Topics
In this second (and final) installment about YAML, Bart teaches us who to write multi-line strings and how not to write multi-line strings. He teaches us about String Blocks which is a bit head-bendy but allows you to write human-readable strings and also tell YAML what to do with empty lines and white space. After that slightly heavy lift, we learn about how to write much simpler-looking Sequences and Mappings than the way we learned in our introduction to YAML in PBS 168. It’s really nifty how you can write them in compact, sensible forms, and even easily combine separate YAML documents into the same sequence or mapping. Finally we learn how to use the `yq` language to query JSON, CSV, and XML files using a language that uses `jq` syntax so you’ll feel right at home. Read an unedited, auto-generated transcript with chapter marks: PBS_2024_07_06 (https://podfeet.com/transcripts/PBS_2024_07_06.html)
Sat, 06 Jul 2024 - 197 - PBS 168 – Introduction to YAML
In Programming By Stealth, we’ve completed our series on the jq language and now Bart Busschots brings us a two-part miniseries about the YAML data format. He takes us through the history of data formats we’ve “enjoyed” such as fixed-width text files, Comma Separated Value files, through to JSON and XML. All of them had their place in history but also had their downsides. YAML promises to be human-readable (yay) and computer-readable (also yay.) Once we’re bought into how YAML is the data format of our dreams, Bart explains that there are only two kinds of data, scalar,s and collections, and that collections can be sequences or mapping and all of these data types go into a document. Luckily this is all of the jargon we’ll have to learn and there are useful synonyms from other languages (e.g. sequences are really just arrays). I found this lesson enjoyable and not too hard on my little brain so I suspect you’ll enjoy it as much as I did. You can find Bart’s fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_06_22 (https://podfeet.com/transcripts/CCATP_2024_06_22.html)
Sat, 22 Jun 2024 - 196 - PBS 167 of X – jq: Recursion, Syntactic Sugar, Some old Friends and a Few Honourable MentionsFri, 07 Jun 2024
- 195 - PBS 166 of X — jq: Processing Arrays & Dictionaries sans Explosion
In this penultimate jq episode of Programming By Stealth, Bart introduces us to three new ways to process arrays and dictionaries without exploding them first. I know that sounds crazy – we’ve always exploded our arrays first. He teaches us how to use the `reduce` operator which lets us take an entire array or dictionary and reduce it down to one thing. The `map` function lets us process every element in an array (or or values in a dictionary) and return a new array. Finally, `map_values` lets us apply a function against all of the values in a dictionary (or an array). It was a bitter sweet ending to the primary series on `jq` for Bart, but next time he’ll do the epilogue where he’ll introduce us to some rarely needed but still very useful things you can do with jq. You can find Bart’s fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_05_25 (https://podfeet.com/transcripts/CCATP_2024_05_25.html)
Sat, 25 May 2024 - 194 - PBS 165 of X – jq: Variables
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. Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_05_11 (https://podfeet.com/transcripts/CCATP_2024_05_11.html)
Sat, 11 May 2024 - 193 - PBS 164 of X – jq: Working with Lookup TablesSat, 30 Mar 2024
- 192 - PBS 163 of X – jq: Lookups & RecordsSun, 17 Mar 2024
- 191 - PBS 162 of X — jq: Altering Arrays & Dictionaries
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.
Sat, 02 Mar 2024 - 190 - PBS 161 of X — jq: Maths, Assignment & String Manipulation
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. Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_02_17 (https://podfeet.com/transcripts/CCATP_2024_02_17.html) Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization (https://github.com/pbs-students). It’s by invitation only but all you have to do is ask Allison!
Sat, 17 Feb 2024 - 189 - PBS 160 of X — jq as a Programming LanguageSun, 04 Feb 2024
- 188 - PBS 159 of X - jq: Building Data Structures
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 (https://auphonic.com). Ok, it’s not magic, but it _feels_ like magic! Read an unedited, auto-generated transcript: CCATP_2024_01_20 (https://podfeet.com/transcripts/CCATP_2024_01_20.html)
Sat, 20 Jan 2024 - 187 - PBS 158B - jq More Advanced QueriesSat, 30 Dec 2023
- 186 - PBS 158A – jq: More Queries
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. Read an unedited, auto-generated transcript: CCATP_2023_12_20 (https://podfeet.com/transcripts/CCATP_2023_12_20.html) Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization (https://github.com/pbs-students). It’s by invitation only but all you have to do is ask Allison! Join the Conversation: • allison@podfeet.com • podfeet.com/slack Support the Show: • Patreon Donation (https://www.podfeet.com/patreon) • PayPal one-time donation (https://podfeet.com/paypal) • Podfeet Podcasts Mugs at Zazzle (https://www.zazzle.com/podfeet_podcasts_coffee_mug-168735677754947563) • Podfeet 15-Year Anniversary Shirts (https://cottonbureau.com/products/podfeet-15-year-anniversary-shirt#/4278978/tee-men-standard-tee-vintage-red-tri-blend-s) Referral Links: • Parallels Toolbox - 3 months free for you and me (https://podfeet.com/parallelstoolbox) • Learn through MacSparky Field Guides - 15% off for you and me (https://podfeet.com/macsparky) • Backblaze - One free month for me and you (https://secure.backblaze.com/r/01zmio) • Setapp - One free month for me and you (https://go.setapp.com/invite/kcqrm2ly) • Eufy - $40 for me if you spend $200. Sadly nothing in it for you. (https://share.eufylife.com/v1/shopping/s/g/e-GkwxRA-) • PIA VPN - One month added to Paid Accounts for both of us (https://www.privateinternetaccess.com/pages/buy-a-vpn/1218buyavpn?invite=U2FsdGVkX182XdJGIOFG6t8UZUmK_QY_fyujdZB6ekM%2C0CVvGHU-flt21G9A5Nj-fL1Yet0) • CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude (https://cleanshot.sjv.io/4P249n)
Wed, 20 Dec 2023 - 185 - PBS 157 of X — jq: Querying JSON with `jq`
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. Read an unedited, auto-generated transcript: CCATP_2023_12_09 (https://podfeet.com/transcripts/CCATP_2023_12_09.html) Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization (https://github.com/pbs-students). It’s by invitation only but all you have to do is ask Allison!
Sat, 09 Dec 2023 - 184 - PBS 156 of X — Extracting Data with `jq`
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. Read an unedited, auto-generated transcript: CCATP_2023_11_25 (https://podfeet.com/transcripts/CCATP_2023_11_25.html) Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization (https://github.com/pbs-students). It’s by invitation only but all you have to do is ask Allison!
Sat, 25 Nov 2023 - 183 - PBS 155 – Introducing JSON Processing from the Shell with `jq`Sat, 18 Nov 2023
- 182 - PBS 154 — Bash: Expansions & Brackets Redux
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.
Sat, 02 Sep 2023 - 181 - PBS 153 – Bash: Functions & Scope
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.
Sat, 29 Jul 2023 - 180 - PBS 152B of X — Bash: xargs & Easier Arithmetic
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. Read an unedited, auto-generated transcript: CCATP_2023_07_08 (https://podfeet.com/transcripts/CCATP_2023_07_08.html)
Sat, 08 Jul 2023 - 179 - PBS 152A of X — Bash: xargs & Easier ArithmeticSun, 25 Jun 2023
- 178 - PBS 151 of X — Bash: Printf and More
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.
Sat, 27 May 2023 - 177 - PBS 150 of X – Bash Script Plumbing (Take Two)
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/…](https://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 `>`, `
Sat, 13 May 2023 - 175 - PBS 149 of X — Better Arguments with POSIX Special Variables and OptionsSun, 16 Apr 2023
- 174 - PBS 147 – Bash ArraysSat, 18 Mar 2023
- 173 - PBS 148 – A Bash Potpourri (Subshells, Relative Paths & More)
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](https://www.podfeet.com/blog/2023/03/pbs-students-github) You can find Bart’s fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript: CCATP_2023_03_25 (https://podfeet.com/transcripts/CCATP_2023_03_25.html) Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization (https://github.com/pbs-students). It’s by invitation only but all you have to do is ask Allison!
Sat, 25 Mar 2023 - 172 - PBS 146 of X – Shell LoopsSat, 04 Mar 2023
- 171 - PBS 145 of X — Shell ConditionalsSat, 18 Feb 2023
- 170 - PBS 144 – Basic Shell Script IO
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.” You can find Bart’s fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript: CCATP_2023_02_04 (https://podfeet.com/transcripts/CCATP_2023_02_04.html)
Sat, 04 Feb 2023 - 169 - PBS 143 — Shell Script Basics
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 (https://books.apple.com/us/book/taming-the-terminal/id1525625941), or access it in a beautiful HTML version at [ttt.bartificer.net/…](https://ttt.bartificer.net/book.html), both of which have the audio of the podcast embedded within. You can find even more formats at [podfeet.com/tttbook](https://www.podfeet.com/blog/download-ttt-book/). Read an unedited, auto-generated transcript: CCATP_2023_01_07 (https://podfeet.com/transcripts/CCATP_2023_01_07.html)
Sat, 07 Jan 2023 - 168 - PBS 142 — The XKPasswdJS Project Kickoff!
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. I’m having a bit of trouble with the transcripts but by the time you read this, you _might_ be able to read an unedited, auto-generated transcript: CCATP_2022_12_10 (https://podfeet.com/transcripts/CCATP_2022_12_10.html)
Sat, 10 Dec 2022 - 167 - PBS 141 — Generating UML Class Diagrams with Mermaid (Don't Cuddle the Mermaid)
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.
Sat, 26 Nov 2022 - 166 - PBS 140 of X — UML Class Diagrams
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 (https://en.wikipedia.org/wiki/Class_diagram). 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.
Sat, 12 Nov 2022 - 165 - PBS Tidbit 6 of Y — A Real-World Webpack Case Study
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](https://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. [audio mp3=“https://media.blubrry.com/nosillacast/traffic.libsyn.com/nosillacast/CCATP_2022_09_17.mp3”] mp3 download (https://media.blubrry.com/nosillacast/traffic.libsyn.com/nosillacast/CCATP_2022_09_17.mp3)
Sat, 17 Sep 2022 - 164 - PBS 139 of X — Bundling a Web App/Site with Webpack (Part 2)Sun, 04 Sep 2022
- 163 - PBS 138 – Bundling a Web App/Site with Webpack (Part 1)Thu, 04 Aug 2022
- 162 - PBS Tidbit 5 of Y — Tips for the Vacationing Programmer
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 (https://podfeet.com/slack) 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/…](https://pbs.bartificer.net/tidbit5)
Sun, 10 Jul 2022 - 161 - PBS 137 of X — Bundling a Library with Webpack
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/… (https://pbs.bartificer.net/pbs137)
Sun, 17 Apr 2022 - 160 - PBS Tibit 4 of Y — Rethinking a Web App – from Web Server to Cloud Stack
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.
Fri, 01 Apr 2022 - 159 - PBS Tidbit 3 of Y
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.
Sat, 19 Mar 2022 - 158 - PBS 136 of X — More Jesting
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.
Sat, 05 Mar 2022 - 157 - PBS 135 of X – Introducing Jest (and re-Introducing Test Driven Development & Unit Testing)Sat, 19 Feb 2022
- 156 - PBS Tibit2 – It's Ok to Play a Different Game!Sun, 06 Feb 2022
- 155 - PBS 134 of X — Firming up our Foundations (2 of 2)
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.
Sat, 22 Jan 2022 - 154 - PBS 133 of X – Firming up our Foundations (1 of 2)Mon, 10 Jan 2022
- 153 - PBS 132 of X — Managing JSDoc
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.
Tue, 21 Dec 2021 - 152 - PBS 131 of X – Introducing JSDocMon, 13 Dec 2021
- 151 - PBS 130 of X – Good Technical DocumentationSat, 27 Nov 2021
- 150 - PBS 129 of X - ESLint with Guest Instructor Helma Van der LindenSun, 14 Nov 2021
- 149 - PBS 128 of X – JavaScript Module BasicsTue, 02 Nov 2021
- 148 - PBS 126 of X - Introducing Phase 2
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
Sun, 03 Oct 2021 - 147 - PBS 127 of X – Introducing NPM (and Node)Sat, 16 Oct 2021
- 146 - PBS 125 of X – Chezmoi on Multiple Computers
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/… (https://pbs.bartificer.net/pbs125)
Sat, 18 Sep 2021 - 145 - PBS 34 of X – More JS Testing with QUnit
In this installment of Bart’s Programming By Stealth series, we review our test code using QUnit, and then learn how to use QUnit to test our code within a real browser page. We do that using the API we built together, the Bartificer Link Toolkit that identifies external links on a web page, makes them open in new tabs, adds the tag rel=noopener, and adds a cute icon to identify them as external links. As always Bart’s terrific written tutorials and downloadable examples are available at pbs.bartificer.net/… (https://pbs.bartificer.net/pbs34)
Sun, 30 Apr 2017 - 144 - PBS 33 of x – JS Testing with QUnit
In this installment of Programming By Stealth, Bart FINALLY lets us start learning Test Driven development, or TDD. He shows us how to use a free and open source tool called QUnit, made by the fine developers of jQuery, to analyze our test code. It’s something I’ve been itching to learn more about, ever since listener Jill tipped us off to the concept. It’s a really fun episode where everything kind of comes together. Hope you enjoy it as much as I did. As always, Bart’s excellent written tutorial for the episode can be found at pbs.bartificer.net/… (https://pbs.bartificer.net/pbs33)
Fri, 14 Apr 2017 - 143 - PB 32 of X – JS Error Handling Revision | HTML Selects
This week Bart and I put the finishing touches on our Date and Time prototypes, then we use those very JavaScript prototypes with HTML forms, we learn bout JavaScript error handling (including throwing and catching errors) and the we start manipulating HTML Selects with jQuery. If that sounds as fun to you as it was to me, check out Bart’s full detailed show notes at pbs.bartificer.net/… (https://pbs.bartificer.net/pbs32)
Wed, 15 Mar 2017 - 142 - PBS 31 of x – JS Static Functions | Checkboxes & Radio Buttons
Bart and I may have broken a record on Chit Chat Across the Pond this week. We went through so much material in Programming By Stealth that this show runs 100 minutes! The funny thing is that I wasn’t ever bored, it was all really interesting. We started by going over last time’s JavaScript challenge where I made some mistakes but node.js saved me so I didn’t realize I’d entirely missed the point. I’m still getting the hang of that object thing. The we learned one final new concept related to JavaScript prototypes: static functions. The we finished that we went over to the html side and learned how to make forms, checkboxes and radio buttons. Not nearly as mentally challenging as JavaScript to be sure, especially since you can see the changes right on screen when you mess with them. Speaking of messing with them, Bart teaches us how to use jQuery to find out what our buttons and checkboxes say and to change them. He does this all with particular attention to using ARIA to ensure our html is accessible. As always you can find his excellent tutorial to follow along at pbs.bartificer.net/… (https://pbs.bartificer.net/pbs31)
Wed, 01 Mar 2017 - 141 - PBS 124 of X – Chezmoi Templates
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/… (https://pbs.bartificer.net/pbs124)
Sat, 04 Sep 2021 - 140 - PBS 123 of X — Backing up and Syncing Dot Files with Chezmoi
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 (https://pbs.bartificer.net/pbs123)
Sun, 22 Aug 2021 - 139 - PBS 122 of X – Managing Dot Files with Chezmoi
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/… (https://pbs.bartificer.net/pbs122).
Sun, 08 Aug 2021 - 138 - PBS 121 of X — Managing Dot Files and an Introduction to Chezmoi
As we’ve become nerdier while learning from Bart, we had started to add hidden configuration files to our Macs and PCs. On the Mac, these configuration files hidden by default by putting a dot in front of them, and hence they are called dot files. Maybe you’ve stored your ssh keys, or in our Git series you created a user-level gitconfig file, or perhaps you’ve installed VS Code or Sourcetree which also add hidden configuration files. In this installment of Programming By Stealth, Bart explains the problem to be solved of how we manage these configuration files if we use multiple computers or migrate to a new computer or do a nuke and pave. He lays the groundwork for why he loves the dot file manager called Chezmoi from chezmoi.io. The installment is a bit of a tease because after learning why we want to have a dot file management tool and why Bart favors Chezmoi for the job, he only lets us install it and run two commands before he says, “And next time we’ll start to use Chezmoi.”
Fri, 23 Jul 2021 - 137 - PBS 120 – Ignoring Files in GitSat, 10 Jul 2021
- 136 - PBS 119 of X — Open Source on GitHub
As promised, Bart takes us through the final step in our GitHub journey - learning how to contribute to an open source project. He explains three open source scenarios: using someone’s code exactly as-is, using their code with a few customizations of your own, and finally the most interesting scenario, customizing the code and contributing your customizations back to the project. When he gets to the final scenario, he gives us a way to practice these newly-acquired skills, and it’s something he’s wanted to do for a long time. He’s created a gallery for all Programming By Stealth listeners to contribute their work they’ve done in the various challenges we’ve worked in Programming By Stealth. If you have your code from the challenges for Conway’s Game of Life, the number guessing game, the currency converter, the currency grid, the world clock or the time sharing clock, we’d love to have you contribute to the PBS gallery to show off your work. Bart explains that the GitHub Pages he’s created will allow us to fork his code, make our own changes, and then create what’s called a pull request to get them accepted into the official PBS Gallery at gallery.pbs.bartificer.net. I worked through the process for one of my projects and it was definitely a learning experience, which is the whole point of Programming By Stealth. Bart’s fantastic tutorial shownotes are availale at [pbs.bartificer.net/…](https://pbs.bartificer.net/pbs119)
Sun, 27 Jun 2021 - 135 - PBS 118 of X — JavaScript Apps with GitHub Pages
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/… (https://pbs.bartificer.net/pbs118)
Sat, 12 Jun 2021 - 134 - PBS 117 of X – Introducing GitHub
In this week’s installment of Programming By Stealth, Bart teaches us how to use GitHub as a public repository for our code, or for anything we write for that matter. He reviews whey he chose Github, and then we dig right in. He does explain the benefits of using SSH to access Github instead of HTTPS, and if you haven’t set up SSH keys before or you’re rusty on the topic, he includes links to our sibling show, Taming the Terminal where you can learn how to do it. We create a new repo from scratch in Github on the web with a README file and a license, and then we get to use a command line version of Github called `gh`. With `gh` we pull the repo down from Github, we edit the files, we commit them locally, and push them back up to Github all from the command line. We then flip the tables and from the command line create another repo directly on Github, create some files, set them up to track and push and pull again to prove it’s working. It’s surprisingly easy and simple. Bart teases us with the next episode where we’ll learn how to create a website using Github pages, which will give us a nice place to host our web apps for free. You can follow along with Bart’s fabulous shownotes at [https://pbs.bartificer.net/pbs117]
Sat, 29 May 2021 - 133 - PBS 116 0f X – Team GitSat, 15 May 2021
- 132 - PBS 115 of X – The Push & Pull of GitSat, 01 May 2021
- 131 - PBS 114 – Tracking Git BranchesSat, 17 Apr 2021
- 130 - PBS 113 of X My First Git RemoteSat, 03 Apr 2021
- 129 - PBS 112 of X – Introducing Git RemotesSat, 20 Mar 2021
- 128 - PBS 111 of X – Stashing ChangesSun, 31 Jan 2021
- 127 - PBS 110 of X – Merge ConflictsSat, 16 Jan 2021
- 126 - PBS 109 of X — SemVar & Structured CommitsMon, 28 Dec 2020
- 125 - PBS 108 of X — Merging & TaggingFri, 18 Dec 2020
- 124 - PBS 107 of X – Branching BasicsSun, 29 Nov 2020
- 123 - PBS 106 of X — Time Travel with GitFri, 20 Nov 2020
- 122 - PBS 105 of X – Seeing the Past with GitSat, 07 Nov 2020
- 121 - PBS 104 of X – Tracking Changes in GitSat, 24 Oct 2020
- 120 - PBS 103 of X — Getting Started With GitSun, 11 Oct 2020
- 119 - PBS 102 of X – Introducing GitSun, 27 Sep 2020
- 118 - PBS 101 of X - Introducing Version ControlSat, 12 Sep 2020
- 117 - PBS 100 of X — Time Sharing Challenge SolutionSun, 30 Aug 2020
- 116 - CCATP #649 – Dr. Helma van der Linden on Creating a Book with Open Source SoftwareFri, 07 Aug 2020
- 115 - PBS - Can We Interest You in a Cup of Taming the Terminal?Sun, 12 Jul 2020
- 114 - PBS 99 of X – Building with Classes Part 2: Is-ASun, 28 Jun 2020
- 113 - PBS 98 of X — Building with Classes Part 1 — Has-ASat, 13 Jun 2020
- 112 - PBS 97 of X — Class Data Attributes & FunctionsSun, 31 May 2020
- 111 - PBS 96 of X — World Clock Challenge SolutionSat, 16 May 2020
- 110 - PBS 95 of X — Better JavaScript Class AttributesSat, 02 May 2020
- 109 - PBS 94 of X — Basic JavaScript OO with ClassSat, 18 Apr 2020
- 108 - PBS 93 – Encapsulation with JavaScript ObjectsSun, 05 Apr 2020
- 107 - PBS 92 of X — Currency Grid SolutionFri, 20 Mar 2020
- 106 - PBS Adjacent: CCATP #628 — Bart Busschots on Creating Automator Quick Actions with JavaScriptSat, 07 Mar 2020
- 105 - PBS 91 of X — JavaScript RE ObjectsSat, 22 Feb 2020
- 104 - PBS 90 of X — JavaScript Wrapper ObjectsSat, 08 Feb 2020
- 103 - PBS Tidbit 1 of Y — Display Values are not Data!Sat, 08 Feb 2020
Podcasts similar to Programming By Stealth
- Global News Podcast BBC World Service
- Kriminálka Český rozhlas
- El Partidazo de COPE COPE
- Herrera en COPE COPE
- The Dan Bongino Show Cumulus Podcast Network | Dan Bongino
- Es la Mañana de Federico esRadio
- La Noche de Dieter esRadio
- Hondelatte Raconte - Christophe Hondelatte Europe 1
- Dateline NBC NBC News
- La rosa de los vientos OndaCero
- Más de uno OndaCero
- La Zanzara Radio 24
- Espacio en blanco Radio Nacional
- L'Heure Du Crime RTL
- El Larguero SER Podcast
- Nadie Sabe Nada SER Podcast
- SER Historia SER Podcast
- Todo Concostrina SER Podcast
- 安住紳一郎の日曜天国 TBS RADIO
- TED Talks Daily TED
- The Tucker Carlson Show Tucker Carlson Network
- 辛坊治郎 ズーム そこまで言うか! ニッポン放送
- 飯田浩司のOK! Cozy up! Podcast ニッポン放送
- 武田鉄矢・今朝の三枚おろし 文化放送PodcastQR