Programming By Stealth
Programming By Stealth is a collaborative podcast by Bart Busschots and Allison Sheridan that teaches real programming in small, manageable steps. It uses the appeal of the web as a motivating project to help learners sneak up on coding concepts. Episodes are designed for beginners and anyone who wants to build practical programming skills without being overwhelmed.
Episodes
PBS 187 — Back to Jekyll
We dust off our memory from where we left off learning about Jekyll back in PBS 181 in June of last year. After some housekeeping, Bart takes us through the challenge solution from PBS 181, and then teaches us how to add metadata to our static sites. After the new material, he sets up where we're going next in learning how to organize our content with Jekyll taxonomies. He even explains what the w
PBS Tidbit 19C — Building a JavaScript CLI App with NodeJS
In this final episode of Tidbit 19, Bart walks us through the very few libraries he used for the final design of his Linkifier CLI App. His choices on tooling to build nice terminal commands and provide color in the terminal (like red for error messages) were based on simplicity, the fewest dependencies, and active support. It was a very fun episode to record as he wrapped the entire story up in a
PBS Tidbit 19B — Building a JavaScript CLI App with NodeJS
We're back with Part B of Tidbit 19, where Bart walks us through the architecture of his Linkifier module. He starts with the three data modeling classes that he's been using for decades, but explains how hard it is today to extract article headlines. He walks through how he developed an extraction logic but had to do it per domain. That sounds crazy but he uses surprisingly few sites for his arti
PBS Tidbit 19A — Building a JavaScript CLI App with NodeJS
In Part A of Tidbit 19, Bart explains the problem he needed to solve, which was bringing a script he's written up into the modern age as a JavaScript command-line interface app that can help navigate the AI landscape. As always, his explanation is geared towards teaching us the fundamentals with his problem as the example.
The shownotes are for Part A and B, but we've only recorded the first half
PBS 186 of X — Web Metadata — the Search and OpenGraph HTML Headers
One of the things that helps your posts get traction is if you have a nice, pretty card that displays when you post the URL on social media. Plain blue links just don't get clicked. With WordPress and other dynamic Content Management Systems (CMSs), you can get plugins to create the pretty cards. But with Jekyll (and Hugo and other Static Site Generators), you need to build the capability into you
PBS 185 of X: Customising Bootstrap 5 with Sass
This final instalment of Sass lays a strong foundation for our return to developing statically generated websites with Jekyll. We learn how to deeply customise and integrate Bootstrap into our own styles. As is often the case, Bart starts by describing the different techniques that can be used to customise Bootstrap with Sass, and then ties it all together with a worked example. We now have the t
PBS 184b of X: Sass Basics
This week, Bart and I recorded the second half of Programming By Stealth installment 184. The first half covered the Sass basics, and in this half, we get to learn through a worked example how to write in Sass, which compiles to regular old CSS. He created a little web page with some wise and humorous quotes from notable people in history, and used everything we learned in the first half to style
PBS 184a of X: Sass Basics
In our most recent installment, Bart taught us how to use CSS "variables" (custom properties) to customize Bootstrap to make your pages not look like every other Bootstrap page on the Internet. He explained at the end that you can take all of this quite a bit further if you learn how to use Sass (Syntactically Awesome Style Sheets).
Sass is a preprocessor for CSS, which means it creates "normal"
PBS 183 of X: Customising Bootstrap with CSS 'Variables'
In our previous installment, Bart taught us how to use CSS "Variables" to style our web pages and web apps. In this installment, he takes it up a notch by showing us how to start with a Bootstrap-enabled page, and still customize the colors, fonts, and more with CSS "Variables".
You can find Bart's fabulous tutorial shownotes and the audio podcast at pbs.bartificer.net.
Read an unedited, auto-ge
PBS 182 of X: CSS 'Variables'
In this very fun installment of Programming By Stealth, Bart teaches us how to use CSS “variables”, which aren’t actually variables (they’re custom properties). These non-variables allow you to take advantage of Bootstrap to style web pages, but make the look and feel all your own. Bart outdid himself on the shownotes, the examples, and the challenge looks super fun.
You can find Bart's fabulous
PBS Tidbit 18 — A Real-World Jekyll Example
Bart taught us about creating static sites with Jekyll and even how to create custom layouts using Bootstrap 5. We learned about Markdown files with YAML front matter and more. In this Tidbit, Bart walks us through how he used everything he learned and taught us to migrate his Let's Talk website from WordPress to Jekyll hosted on GitHub Pages. It's a fun episode because we learn what worked well,
PBS Tidbit 17b — Simplifying Developer Setups with Docker
This instalment is the second half of PBS Tidbit 17 in which Helma van der Linden is the instructor and Bart Busschots is the student. We pick up the plot right where Helma begins to teach how to reuse the Docker image created in the first half of the lesson.
You can find Helma's fabulous tutorial shownotes and the audio podcast at pbs.bartificer.net
Join the Conversation:
allison@podfeet.com
PBS Tidbit 17a — Simplifying Developer Setups with Docker
This very special episode of Programming By Stealth is a Tidbit written and taught by the lovely Helma van der Linden. Bart has wanted to understand Docker better, and Helma has some great use cases for how to use them for developer setups so it was a good opportunity for Bart to learn from Helma.
The material is quite long, so the podcast was recorded in two segments, Tidbit 17a and b. Tidbit b
PBS Tidbit 16 — How Podfeet.com Works
Bart continues his unofficial series where he listens for where I say, "I wish I understood..." This time, he explains the history of how Podfeet.com has evolved over the last 20 years. We started with a shared server, then a virtual machine, to a dedicated server, and to a separate database server. He explains how the LAMP Stack works (Linux, Apache, MySQL, and PHP) and all the work Apache had to
PBS Tidbit 15 — Building an Indie Author Site with Hugo by Eddie Tonkoi
This week, we have a guest contribution by the fabulous Eddie Tonkoi. He walks us through his journey to move his wife's book series website using a static site generator called Hugo. He hosts the generated files on GitHub and serves them (for free) through Cloudflare.
You can find Eddie's fabulous tutorial shownotes and the audio podcast at pbs.bartificer.net.
Read an unedited, auto-generated t
PBS Tidbit 14 — Coding with AI
You can find Bart's fabulous tutorial shownotes and the audio podcast at pbs.bartificer.net.
Read an unedited, auto-generated transcript with chapter marks: PBS_2025_10_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!
Join the Conversation:
allison@podfeet
PBS Tidbit 13 — PowerShell Tames Monty
Bart had an itch to scratch, and he decided to scratch it with PowerShell. You'll remember that he gave us a teaser Tidbit seven months ago in Tidbit 11, and we still haven't started learning PowerShell so this one is yet another teaser. The itch he had was trying to understand the "Monty Hall Problem" [en.wikipedia.org/...](https://en.wikipedia.org/wiki/Monty_Hall_problem), and by writing a scri
PBS 181 of X — Reusable Snippets with Jekyll Includes
We've been having great fun in Programming By Stealth learning how to use Jekyll to create a website using GitHub Pages. This week Bart goes through the challenge he left us with last time — to add a nav bar to our little static website using Bootstrap 5 along with Jekyll and Liquid templates. Bart had a lot of fun with his solution so it was fun to hear him dust off the cobwebs on Bootstrap.
The
PBS 180 of X — Theming Jekyll
We continue our series on making websites using GitHub Pages. Building on our Jekyll knowledge with Liquid templates, we now learn how to create our own theme with Jekyll layouts. The terminology of Jekyll is still tricky, but with some worked examples and a challenge this time, maybe it will start to cement in our brains!
You can find Bart's fabulous tutorial shownotes and the audio podcast at p
PBS 179 of X — Introducing Liquid Templates in GitHub Pages with Jekyll
In this episode, Bart continues teaching us about GitHub Pages using Jekyll by introducing us to Liquid Templates. Liquid allows us to move from adding static content to our web pages to auto-generated information. It's a lot for one lesson, and some of the terminology is a little weird, but as always, Bart's worked example brings it home.
You can find Bart's fabulous tutorial shownotes at pbs.ba
PBS Tidbit 12 — XKPasswd Rewrite Exits Beta
In this tidbit episode of Programming By Stealth, Bart Busschots and Helma van der Linden start by reviewing how she took the reins of the XKPasswd project to first convert it from Perl to JavaScript, then to rewrite the web app. After that, she separated the JavaScript library from the web app code. This episode is primarily walking through exactly how she accomplished that split. And now XKPassw
PBS 178 of X — Getting Started with Jekyll Pages
Last time we learned how to install Ruby, install Bundler, install Gems, and build a very simple website using Jekyll as our static site generator into GitHub. In this installment of our Jekyll miniseries, Bart explains Jekyll's build process which is mostly automated by how you name things and the content of the files you create (like adding YAML front matter.) Then we spend some quality time bem
PBS 177 of X — Publishing A Basic Jekyll Site (GitHub Pages)
In our miniseries on GitHub Pages, we learn how to create a basic Jekyll site. To do this, we must install a modern version of Ruby, install its Gem Bundler, create a little placeholder site, and then serve Jekyll to view our site locally. We push it to GitHub where the GitHub Actions we learned about last time do their magic and create a real website all for free. But we didn't stop there. One of
PBS 176 of X — Deploying a JavaScript Web App with Webpack & GitHub Actions
Way back in September of 2022, Bart finished off the Webpack miniseries by leaving it as an exercise for the student to deploy their web apps to GitHub Pages. Bart closes that circle in this installment while teaching us how to use GitHub Actions. We learn about workflows, jobs, steps, events, and runners. Bart includes great tables in the shownotes of the terminology, so we now have a handy refe
PBS 175 of X — GitHub Pages: Static Site Generators
In Programming By Stealth this week, Bart has started a new miniseries to teach us how to use GitHub Pages to create a website (for free.) In PBS 175, he starts by explaining what Static Site Generators (like GitHub Pages) are, and the pros and cons vs. a more traditional content management system like WordPress. Neither are wrong, they just solve the same problem in different ways. He then gives
PBS Tidbit 11B — A PowerShell Teaser
As promised, we're back with part 2 of the Powershell Teaser. We pick up where we left off, starting with learning about parameter definitions and the advantages such a structured language affords us, including automatically generated help files and error checking. Bart updated the shownotes to include valuable resource links to take your PowerShell to a higher level.
We walk through our plan for
PBS Tidbit 11A — A PowerShell Teaser
Bart Busschots is enamored with the open source shell from Microsoft called PowerShell. His goal was to give us a teaser on this modern shell but there was enough material in his shownotes that we're recording the audio in two halves. Feel free to read ahead in the shownotes if you like, or you can wait till the second installment to read the rest.
In this first half, we learn about how Bart begr
PBS Tidbit 10 — Run LLMs Locally with Ollama with Steve Mattan
In a very unusual Tidbit episode of Programming By Stealth, Allison interviews NosillaCastaway and Programming By Stealth student Steve Mattan about how he's running Large Language Models locally on his Mac. He pulls this off using a series of open source tools, starting with Ollama for the models from the command line, and then Enchanted to give him a nice GUI. He explains how he's integrated the
PBS 174 of X: Working with Git Submodules
In this installment of Programming By Stealth, Bart completes his miniseries on Git Submodules. Last time he created an imaginary company with three developers and went through three relatively simple scenarios where Git submodules were implemented. In this finale installment, he takes it up a notch in complexity and we actually get to push submodule changes. The path is fraught with danger and I
PBS 173 of X: Getting Started with Git Submodules
In PBS 172 Bart Busschots explained what Git submodules are and the kinds of problems they solve. In this practical lesson, he walks us through three scenarios where we actually get to type in Git commands to learn how the process works. We get to pretend we're in a small web app business where company branding is important.
In the first scenario, we're a new developer joining an app team and we
PBS 172 of X: Git Submodules
Bart takes us back into our Git miniseries to explain Git submodules, which are essentially nested Git repos. After we learn what they are, he explains why nesting is needed. Then he takes us through three use cases as a way of illustrating the kinds of problems Git submodules can solve.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
Join our Slack at podfeet.com/slack an
PBS Tidbit 9 – Using Git on iOS
In ye olden days, iOS kept everything sandboxed in a way that apps weren't allowed to reach outside of their own data to open individual files. But with the aptly named Files app, and an API to allow a human to do the picking, apps can now open files directly on iOS.
This "innovation" allows us to have a Git client on iOS and have it use a linked repo that's stored in the Files app. This means we
PBS 171 of X: MVC in XKpasswd-js
We have a bit of a changeup for today's lesson. While Bart Busschots is in attendance for this episode, he is not be the instructor, he is a student like me. Our instructor today is the delightful Helma van der Linden and she's going to teach us about how she applied the Model View Controller pattern to our project XKPasswd.
You can find Helma's fabulous tutorial shownotes at pbs.bartificer.net.
PBS 170 of X: Model View Controller (MVC)
We're back from our summer hiatus (actually scheduled for the first time ever instead of accidentally happening!)
In this week's episode, Bart takes on the task of explaining the philosophy behind why having a framework for software development is useful and even crucial as projects get bigger and more complex. We chose this topic because the XKPasswd project has already started using a framework
PBS Tidbit 8 – Interview with jq Maintainer Mattias Wadman
In this Tidbit version of Programming By Stealth, Bart Busschots interviews Mattias Wadman, one of the maintainers of the jq project. This was great fun as we just finished learning jq in Programming By Stealth.
Read an unedited, auto-generated transcript with chapter marks: PBS_2024_08_06
You can find out more about Mattias & the various projects he is working on at the links below:
F
PBS Tidbit 7 – jq to Analyze macOS Installed Apps with Helma van der Linden on
In this special tidbit installment of Programming By Stealth, Helma van der Linden joins Allison to walk through how she solved a real-world problem using jq. The problem to be solved was a need to analyze the installed applications on her Intel-based Mac before migrating to her new Apple Silicon Mac.
She used a built-in Terminal command to access System Information to create a JSON file, and th
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 Sequenc
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
PBS 167 of X – jq: Recursion, Syntactic Sugar, Some old Friends and a Few Honourable Mentions
It was actually bittersweet for Bart and me this week as he taught the final installment in our series of Programming By Stealth about jq. As Bart says partway through our recording, he thought this would just be a few episodes but it took 13 episodes to go through everything Bart thought was fun about this deceptively simple programming language.
This final installment in the jq series covers q
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 ele
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 an
PBS 164 of X – jq: Working with Lookup Tables
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 t
PBS 163 of X – jq: Lookups & Records
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.
T
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 reve
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 diffe
PBS 160 of X — jq as a Programming Language
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 th
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.
PBS 158B - jq More Advanced Queries
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 l
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 funda
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,
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
PBS 155 – Introducing JSON Processing from the Shell with `jq`
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
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
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 tim
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 B
PBS 152A of X — Bash: xargs & Easier Arithmetic
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, h
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 format
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 e
PBS 149 of X — Better Arguments with POSIX Special Variables and Options
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 inte
PBS 147 – Bash Arrays
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 octotho
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
PBS 146 of X – Shell Loops
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.
En
PBS 145 of X — Shell Conditionals
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 4 is actually > 10), but he gets us there in the end
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 a
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 charact
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
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
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 r
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
PBS 139 of X — Bundling a Web App/Site with Webpack (Part 2)
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 w
PBS 138 – Bundling a Web App/Site with Webpack (Part 1)
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
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
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 worki
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 quart
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 u
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 p
PBS 135 of X – Introducing Jest (and re-Introducing Test Driven Development & Unit Testing)
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 t
PBS Tibit2 – It's Ok to Play a Different Game!
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 call
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 counterin
PBS 133 of X – Firming up our Foundations (1 of 2)
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 p
Recommended
Solved Murders - True Crime Stories
紐約鳥｜New York Aperture
The Swerve Podcast: Obscure Topics | Conspiracy Theories
The Bread and Banter Podcast
The Church of What's Happening Now: The New Testament
Busted Open
Deadline: White House
Crickets Corner
History of the Earthquake and Fire in San Francisco
Fox news
K-Drama Obsessed Mamas | Beyond “Just One More Episode!”
True Crime Classics
