Programming By Stealth

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.

Referral Links:

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.

Read an unedited, auto-generated transcript: CCATP_2023_03_04

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

Read an unedited, auto-generated transcript: CCATP_2023_02_18

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

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

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

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.

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.

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

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.