Programming By Stealth

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. Then we turn to learning about Jekyll's `includes` feature, which is reusable snippets similar to how TextExpander snippets let you write something and change it in only one place. The worked examples simplify the code in a way, and we learn how to use `includes` to create advanced image markup. I also enjoyed learning about Liquid comments and how you can create white space between sections of your code for ease of writing and debugging that then never show up in the resultant HTML.

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 pbs.bartificer.net.

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

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 XKPasswd is officially out of beta and available at xkpasswd.net You can find Helma's fabulous tutorial shownotes and the audio podcast at pbs.bartificer.net.

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 bemoaning how the Jekyll developers reuse the word "assets" to mean two different things. Bart avoids some of the associated confusion by creating some naming conventions of our own. We get to do a worked example where we learn a little bit about Pages in Jekyll and do a few things the hard way that we'll redo the easy way in the coming installments. If you're following along realtime, note that we won't be recording for 6 weeks because of some birthdays and Allison's trip to Japan.

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 our goals is to create our own theme, and to build on what we get with Bootstrap. We actually download the source, not compiled version of Bootstrap and pick and choose the files we want to use. While learning about the standard conventions for directory structure in Jekyll sites, we'll also learn about Sass — Syntactically Awesome Style Sheets — and how Jekyll will turn them into standard CSS. It's a bit of a heavy lift in terms of a lot of moving pieces, but no one bit of this was hard to learn. It was great fun, and this is just the beginning of what we're going to learn about using Jekyll as a fully-functional content management system.

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 reference guide for making our own YAML files to run GitHub actions. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: PBS_2025_02_15 Join our Slack at podfeet.com/slack and check out the Programming By Stealth channel under #pbs. Support Bart by going to lets-talk.ie and pushing one of the big blue support buttons. Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 us the framework for the tools we'll be using and lays out the next few lessons where we'll get in and get our hands dirty. I'm extremely excited about this miniseries and I hope you will be too. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: PBS_2025_02_01 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.com podfeet.com/slack Support the Show: Patreon Donation Apple Pay or Credit Card one-time donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 2025, where Bart is going to teach us about GitHub Pages (which power the Programming By Stealth shownotes) and then how to change the style you see with Bootstrap to make it your own. After that we expect to get back to PowerShell but that's a ways down the road so things could change.

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 begrudgingly started using PowerShell and what made him become such a fan. He walks us through the philosophy and then the structure of commands first. We get to play with a few tiny scripts to illustrate how the "plumbing" works in PowerShell and we learn about how message streams work with data streams. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Join our Slack at podfeet.com/slack and check out the Programming By Stealth channel under #pbs. Support Bart by going to lets-talk.ie and pushing one of the big blue support buttons. Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 local LLM into VSCode for his coding, and how he uses Keyboard Maestro to launch all of this at once. You can find the outline and links to how Steve's doing this at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: PBS_2024_12_07 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.com podfeet.com/slack Support the Show: Patreon Donation Apple Pay or Credit Card one-time donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 get stuck on the very last scenario but Bart wouldn't let me give up and eventually helped me understand. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: PBS_2024_12_07 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.com podfeet.com/slack Support the Show: Patreon Donation Apple Pay or Credit Card one-time donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 have a repo that already includes the branding submodule. In the second scenario, we're a seasoned developer on the team creating a new app and we need to import the branding submodule. Finally, in the third scenario, we're one of the brand designers and we want to update the branding. In the third scenario we learn two different ways to incorporate the branding changes into our web apps. I'm always happy when I get to play along in the Terminal, so this lesson was great fun. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Join our Slack at podfeet.com/slack and check out the Programming By Stealth channel under #pbs. Support Bart by going to lets-talk.ie and pushing one of the big blue support buttons. Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 and check out the Programming By Stealth channel under #pbs. Support Bart by going to lets-talk.ie and pushing one of the big blue support buttons. Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 can use any text editor we like to open the repos files for editing. In this tidbit episode of Programming By Stealth, Bart walks us through how to configure the iOS Git client Working Copy to clone a repo from GitHub, and then open the files in his favorite text editor on iOS, Textastic. Hat's off to Jill of Kent that explained to Bart and me more than a year ago that this was possible, but a fist shake to Bart for not telling me how to do it till now! You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Join our Slack at podfeet.com/slack and check out the Programming By Stealth channel under #pbs. Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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. Join the Conversation: allison@podfeet.com podfeet.com/slack Support the Show: Patreon Donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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 called Model View Controller. We get the barest understanding of MVC in this explanation from Bart, and the next episode of Programming By Stealth will be the wonderful Helma van der Linden explaining the details of her implementation of MVC for the XKPasswd project. In the first episode of its kind, I won't be the only student in the class - Bart and I will be learning together. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Join the Conversation: allison@podfeet.com podfeet.com/slack Support the Show: Patreon Donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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: Follow Mattias on Mastodon: @wader@fosstodon.org Mattias' GitHub Profile which hosts some notable jq-related projects: fq for querying binary files with the jq language: github.com/wader/fq A list of presentations about fq — github.com/… The fork of the Go version of jq that powers fq — github.com/… The language definition file for adding jq support to IDEs like VS Code: github.com/wader/jq-lsp jq implemented in jq: github.com/wader/jqjq Some notable jq commits & files mentioned during the interview: The very first commit in Haskel The switch to C jq's main function which is written in jq — https://github.com/… A version of jq implemented in Go: github.com/itchyny/gojq A version of jq implemented in Rust by Michael Färber: github.com/01mf02/jaq Michael's formal specification of the jq language — github.com/… The “Denotational Semantics and a Fast Interpreter for jq” academic paper by Michael

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 then used a series of jq filters to remove data she didn't need, and format what she kept into human-readable form. Helma walks us through every step of the way as she built up her jq script file to massage the data to her needs. At the end Allison explains how to take Helma's final CSV output and analyze the data in a spreadsheet using a pivot table.

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

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

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 querying nested data structures with the `recurse` command. One of the really fun parts of the episode is when he teaches us how to dramatically simplify our code, a concept that's often called syntactic sugar. We get to do `if` statements for the first time, where I wondered why he didn't let us have them earlier! I was cross with him for holding out on us with `try-catch` too because it would have made our coding so much easier. But that was the real theme of this installment – we had to learn the way everything works before learning the shortcuts. In the finale, he gives us a few of what he calls "honourable mentions" – little tidbits that came in handy at times. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript with chapter marks: CCATP_2024_06_07 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!

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

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

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

In this episode of Programming By Stealth, Bart Busschots as usual works through his solution to the challenge from last time, and as usual I learn a lot more about how to use jq to solve problems. He takes a bit of a detour to explain a fun email we got from Jill of Kent in which she explained the vast number of headaches you'll run into when trying to alphabetize names no matter the language. Then we buckle down and learn about how to make tradeoffs between speed and efficiency of resources, and how jq lookups can help us. Bart also helps us understand _when_ lookups can help us with querying JSON files. This episode is more of a lecture, which is fine because he's introducing a new concept and explaining some philosophy. You won't hear me breaking into the conversation very much but it's only because I'm not confused! Don't worry, when we get into the final example you'll hear me get confused! Bart explains it about 3 or 4 times and when you hear why your co-host here was confused, it's kind of ironic. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.

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.

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

In this week's installment of Programming By Stealth, Bart Busschots teaches us how to use jq as a programming language. Before we get into the new stuff, Bart takes us through his solution to the challenge, and I have to say I was pretty chuffed when he said my solution to the extra credit portion was more elegant than his. To be fair, it took a buddy programming session with him for me to get the _first_ part of the challenge figured out. When we got into the programming language part of the lesson, there were so many times that I said, "I needed this last week!" I think finding out these options are available after understanding the problems they solve was fantastic. We learned how to run jq filters from files, which means no more looking at our filters all on one line - we can put line feeds and indents into our filters to make them more readable. We can even add comments. Bart tells us about a couple of handy plugins for VS Code to give us syntax highlighting which will be swell. My favorite thing I learned was how to add debugging to our filters. This one is a life changer. We explore a few functions for exploring data filters that will make life easier. We wrap up with an introduction to jq variables, which the developers of jq really don't want you to use unless absolutely necessary.

In this very meaty episode of Programming By Stealth, Bart Busschots teaches us how to build data structures using jq with JSON files. We're not just querying existing data, we're rebuilding the data the way we want to see it. We learn how to build strings with interpolation, which I find is a very odd word to describe the process. It's really like concatenation in Excel, but maybe that's just me. We build arrays using jq, and even convert between strings and arrays with the `split` and `join` commands. We build dictionaries in a syntax that is simple and elegant. We also build dictionaries from strings using `capture` with Regular Expressions. We learn not to do string formatting and escaping using `@` – for example `@csv` can automatically create comma-separated values data for us and @uri can escape characters for us in a URL we build using jq. Like I said, it's a meaty episode but Bart and I both enjoyed the lesson quite a bit. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. And just in case I forgot to mention it earlier, remember that we now have transcripts with chapter breaks. This means you can jump pretty easily to a topic to reread exactly how Bart explained something. You even get a time stamp of when he talked on that subject, allowing you to easily skim to the portion of the audio you want to rehear for clarification. All thanks to the magic of Auphonic. Ok, it's not magic, but it _feels_ like magic! Read an unedited, auto-generated transcript: CCATP_2024_01_20

Two weeks ago, Bart Busschots and I recorded a Programming By Stealth episode covering more queries using the jq language on our JSON files. We spent so much time working through the challenges from the previous installment that we only made it halfway through his tutorial shownotes. So this week we're back with the second half of that episode, Programming By Stealth 158B. Before we got started learning, I alerted the audience to a significant enhancement to the material we create for this show. I use a service called Auphonic to do a lot of things with the audio file when we're done recording, including leveling the audio, adding metadata to it, converting it to an MP3, and FTPing it to the server for the listeners to download. Auphonic has recently added AI-generated transcripts which we've had for a while with Programming By Stealth. The NosillaCast has chapter marks you can use to jump to content in the audio file, but Chit Chat Across the Pond has never had that. Auphonic now adds auto-generated chapters based on the content in the audio file. These chapter marks are in the transcript, which allows you to jump to the text of where we cover a specific topic. Not only that, these auto-generated chapters are in the audio file so in your podcatcher you can now jump to different sections instead of having to scroll through to find something Bart explained. The chapter marks are not perfect, and we have no intention of editing them, but it should give you an easier way to find what you want to re-listen to or re-read. While Bart has spectacular tutorial shownotes, the transcript gives you the full flavor of the conversation we have while Bart is teaching me. Now back to this week's show! In this week's episode, Bart explains two powerful commands for searching JSON files with jq, the `contains` and `inside` functions. In this context, he goes through testing for containment with strings, arrays, dictionaries and he tells us about default containment. Then he explains how the `inside` function does essentially the opposite of testing for containment. Finally, he shows us how to use regular expressions with the `test` function to get as granular as we like with our jq filters. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript: CCATP_2023_12_30 Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It's by invitation only but all you have to do is ask Allison!

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 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.com podfeet.com/slack Support the Show: Patreon Donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us CleanShot X - Earns me $25%, sorry nothing in it for you but my gratitude

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

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

After our annual break from Programming By Stealth that happens at an unknown time for an unknown length every single year, Bart and I are back with a new episode of Programming By Stealth. Bart introduces us to a language called jq _and_ a terminal command called `jq` which together are used to help query JSON files, see "pretty versions of them, and also to manipulate them. We don't learn a lot of commands but Bart walks us through a few examples to help illustrate why we care, or shall I say, "the problem to be solved"? I'm sold on the idea having just mucked about in a config files for homebridge this week. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript: CCATP_2023_11_18 Join our Slack at podfeet.com/slack and look for the #pbs channel, and check out our pbs-student GitHub Organization. It's by invitation only but all you have to do is ask Allison!

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.

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.

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

I don't always make the time to pre-read the shownotes for Programming By Stealth but I never regret when I do make the time. That was especially true this week. In this installment, Bart Busschots takes us through his solution to the challenge from PBS 151, which was to print a "pretty" multiplication table using the `printf` command. Being Bart, he didn't just make the columns line up nicely, he took it up a notch and added ASCII characters that build a nice border and corners around his table. The reason I said it was good I pre-read the shownotes is that while nearly everything he explains in this lesson was a reuse of things he's taught us before, the commands are so dense in Bash that it was particularly hard to read and comprehend. We had also taken 4 weeks between lessons which made it even harder to remember. Because I told Bart ahead of time that I was going to be stopping him to ask lots of questions, we decided to skip the one main topic he had planned to explain - `xargs`. This means that the next installment will start with `xargs` as Programming By Stealth 152B using the same shownotes. I'm really glad we did it this way because instead of you having to listen to a confused and thus frustrated Allison, the lesson flows well with me having time to ask the right questions. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.

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.

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 `>`, `

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 `>`, `

In this rather mind-bendy episode of Programming By Stealth, Bart Busschots takes into the weird world of POSIX special variables and options. He refers to some of them as being like handling nuclear power, at one point he suggests mind-altering drugs must have been involved in the design, and he even compares one of our newly learned tools to a chainsaw. He powered us through amidst my many interruptions with questions to where we can now write shell scripts that take flags and optional arguments using `getopts`. The final form of the syntax is very readable but knowing the reasons behind each bit is crucially important. You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net. Read an unedited, auto-generated transcript: CCATP_2023_04_15

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

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. Join the Conversation: allison@podfeet.com podfeet.com/slack Support the Show: Patreon Donation PayPal one-time donation Podfeet Podcasts Mugs at Zazzle Podfeet 15-Year Anniversary Shirts Referral Links: Parallels Toolbox - 3 months free for you and me Learn through MacSparky Field Guides - 15% off for you and me Backblaze - One free month for me and you Setapp - One free month for me and you Eufy - $40 for me if you spend $200. Sadly nothing in it for you. PIA VPN - One month added to Paid Accounts for both of us

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.