Programming By Stealth: Recent Episodes
Bart Busschots & Allison Sheridan
A collaborative project between Bart Busschots and Allison Sheridan to sneak up on real programming in small easy steps, using the allure of the web as the carrot to entice people forward.
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.
You can find _Helma's_ fabulous tutorial shownotes at pbs.bartificer.net.
Read an unedited, auto-generated transcript with chapter marks: PBS_2024_07_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!
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/..., Bart taught us about stream redirection, or what he likes to call Terminal Plumbing. This was a long time ago and many folks may not have listened to that great series. Bart takes us through it again but from the perspective of writing Bash scripts that can do everything we can do in the Terminal. We learn about Standard Input (STDIN), Standard Output (STDOUT), and Standard Error (STDERR). We also learn how to bifurcate STDOUT and STDERR to produce desired results. He walks us through how to use the symbols >, <, and our friend the pipe | to redirect output from commands and files. I did get stuck for quite a while in a few spots here and there. Bart continues to try to convince me that if I'm confused, at least one other learner is as well, so hopefully making Bart find different ways to explain these things to help me will help you.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
Join our Slack to talk to other Programming By Stealth learners by going to podfeet.com/slack.
Bart and I took a few minutes upfront to high-five each other for 150 episodes of the Programming By Stealth Podcast. Then we quickly got to work.
Back in the Taming the Terminal podcast (at ttt.bartificer.net/..., Bart taught us about stream redirection, or what he likes to call Terminal Plumbing. This was a long time ago and many folks may not have listened to that great series. Bart takes us through it again but from the perspective of writing Bash scripts that can do everything we can do in the Terminal. We learn about Standard Input (STDIN), Standard Output (STDOUT), and Standard Error (STDERR). We also learn how to bifurcate STDOUT and STDERR to produce desired results. He walks us through how to use the symbols >, <, and our friend the pipe | to redirect output from commands and files. I did get stuck for quite a while in a few spots here and there. Bart continues to try to convince me that if I'm confused, at least one other learner is as well, so hopefully making Bart find different ways to explain these things to help me will help you.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
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
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/..., both of which have the audio of the podcast embedded within. You can find even more formats at podfeet.com/tttbook.
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 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.
We're back in the saddle after a summer of "PBS Adjacent" installments. Our last real PBS was learning how to use Webpack to bundle a JavaScript library for sharing with the world. That was cool, but a lot of us want to use Webpack to bundle a web app we've written ourselves to include all of the libraries we're using. We also want to have an easier way to reduce dependency on having an Internet connection. We also want an easier way to keep our bundle of libraries up to date. In this installment, Bart teaches us how to do all that with NPM and Webpack. I really enjoyed this episode because he used a worked example to show us how it all works, rather than talking only about the theory. The repetitive steps for each library really helped me to understand the process.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
I'm about to go on vacation where I suspect I'll have little to no Internet to play with. It would be really cool if I could use any downtime (like on the 11-hour plane flight) to do some programming. Unfortunately, our code is often filled with references to content delivery networks to get needed libraries like jQuery and Bootstrap. While on my walk on Friday I was mentally preparing a post for our PBS Slack community to ask them how I can modify my code so that it doesn't require the Internet to function.
Imagine my surprise and delight when I saw Bart's topic for this week's Programming By Stealth - it's all about how to do exactly what I wanted. He covers how to prepare your computer for departure, how it's important to clone any repos you might want to reference, and most importantly how to localize your dependencies and then what to undo when you return home.
It was exactly everything I needed to know and I hope it helps you too whenever you disconnect from the Net but still want to play with your code.
You can read Bart's fabulous shownotes for this installment at pbs.bartificer.net/...
We have one more thing to learn as we gear up to actually start writing modern code for Bart's HSXKPasswd tool. The last piece of our tool kit is a bundler. In this installment Bart teaches what problems bundlers solve, and he explains why he chose the bundler Webpack for our project. After learning about Webpack, Bart takes us through a worked example, bundling the Joiner module we've been working on through this part of the series. When we're done, we'll have an ES6 bundle and a Universal Module Defnition (UMD) bundle to cover both modern and more legacy needs. In the episode you'll hear me say that the exercise hit errors, and after the show we diagnosed the problem and fixed the shownotes so have no worries about that!
You can, as always, find Bart's fabulous show note tutorial for this installment at pbs.bartificer.net/...It's Showtime
Over the past few months, podfeet.com went through a period of really poor performance. My site hadn't been snappy in the last few years with page loads of up to 6 seconds, but it hit a tipping point where it was taking in excess of 40 seconds for pages to load. William Reveal and Bart migrated the services behind podfeet.com that improved performance to where most pages load in less than a quarter of a second.
In this Programming By Stealth adjacent episode, Bart wanted to walk through the structure of what makes up a web server, what a web server does, what all of the components are, and then walk us through how these things have changed in the nearly 17 years podfeet.com has been around. As we continue our journey in Programming By Stealth we are moving from the client-side to the server-side, so this lesson is quite relevant to helping our fellow learners understand what's behind the next steps we'll be taking.
There's no homework in this episode but it's also challenging to keep the pieces straight in your head so get ready for a fun and instructive "Tidbit".
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
In this Programming By Stealth adjacent installment labeled Tidbits 3 of Y, Bart Busschots talks to us about the dangers of using other people's code in your code, and the danger of not using other people's code. He explains this seeming dichotomy and gives us ways to approach the problem taking a middle ground. He helps us think about how to choose whether to use other's code and whose code to use, and even how to ensure it's kept up to date with security patches. It's definitely a philosophical installment and it was triggered by a recent event where a developer maliciously broke his own code, impacting a lot of developers. It's actually sort of a success story of open source which I didn't expect.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
Bart Busschots taught us the basics of Jest last time for our Test Driven Development environment. This week we learn to group our tests using the describe() function in Jest. Grouping tests with describe does more than eliminate the need to comment our code, it also provides more useful output from our tests and scopes what happens inside.
As Bart describes it, we climb "Mount Jest" at one point as he explains how we can also loop our tests (instead of repeating code as we did last time) using describe.each()(). It's a little head bending with arrays of arrays and functions of functions but it sounds worse to describe than it actually is to read and create.
He then describes ways to run certain setup and tear down functions before and after our tests are run and why we might need to do that.
Finally, we get the last cool thing we'll need to understand about Jest, and that's how to use the .only and .skip modifiers on our tests so that we can focus on individual tests while we're chasing bugs.
For the first time in a long time, he even gives us an optional challenge to flex these new Jest muscles.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
In this week's installment of Programming By Stealth, Bart takes us down memory lane to 102 episodes ago when he first introduced us to the concept of test-driven development. He explains why back then he taught us how to use QUnit for our TDD work, and why it's no longer in favor with him. It's not just the advancements in technology like ES6, but it's also because QUnit makes it terribly hard to write tests and to interpret what you've written when you've been away from it for a while. He walks us through his criteria for picking a new TDD tool, and why he chose Jest for the job.
He then walks us through a worked example of how to write some simple tests on a module and of course, explains how Jest does its job running our tests. I liked it, even though my head hurt during a bit of it!
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
This episode of Chit Chat Across the Pond perfectly straddles the line between Programming By Stealth and Lite. While it's definitely a nerdy discussion topic, Bart Busschots is really just telling a story. He starts by explaining how he ended up a computer scientist essentially by accident, and tells us about a fantastic CS professor he had who inspired him through an assignment about a game called 8 Queens. He tells these stories as a way to explain that when I used the Terminal and egrep to help me solve the game Wordle a few weeks ago, it wasn't really cheating. I think whether you're a programmer or not, you'll enjoy hearing Bart explain why.
Bart's shownotes can be found at pbs.bartificer.net/...
In this installment of Programming By Stealth, Bart Busschots finishes firming up our foundation on a few more things before we meet Jest, which will be the Test Driven Development (TDD) environment we'll be learning next time.
He explains in some adorable examples involving a parrot (named Polly of course) how getters can be used to construct short but powerful syntaxes that seem quite counterintuitive at first glance. These are heavily used by Jest, and without learning about them, they would simply look like magic. He said some purists may see this syntax as an abuse of getters but it's a pretty slick method that yields very readable APIs.
The second thing he teaches us is that functions can actually return functions. That sounds like opening a hole in the space-time continuum but it's actually quite logical and useful as Bart explains the usefulness of this really well. No parrots involved, but lots of pancakes and waffles in his examples.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net.
In this installment of Programming By Stealth, Bart Busschots takes us through some review in order to prepare us to begin our journey into test driven development (TDD) with the tool Jest which he's chosen for our TDD. He clears up some confusion on the difference between npm install and npm ci, and then he gives us more guidance on when to use which JSDoc tags, especially when documenting plain objects. He gives us a refresher on the different ways of defining functions, and especially arrow functions which are heavily used by Jest. Jest also uses function chaining heavily so he reminds us of how that works as well.
Even if you remember all of this and had it all clear in your head (I most definitely did _not_) it's great to have all of this content in one post as reference.
The next installment will continue firming up our foundation with some new concepts that are heavily used by Jest.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net
In this final Programming By Stealth and final Chit Chat Across the Pond for 2021, Bart teaches us how to manage our documentation in JSDoc. As any good programmer, he insists on automating as much as he possibly can. He starts by showing us each step that we have to do at the command line, and methodically puts together a JSDoc configuration file that runs scripts and helps create documentation directories, and installs plugins.
Even better he helps us to configure JSDoc so that it will alert us if we make a mistake in our inline or block tags, since JSDoc by default just ignores those mistakes. Finally we walk through three different themes for our documentation and we actually choose one for the XKPASSWD project and he shows us how we can even modify the theme. It all has to do with Bart preferring blue over purple.
It's great fun, and really gives us the tool we need now to get ready for the next step. You can follow along with Bart's fabulous tutorial show notes pbs.bartificer.net.
In our last installment, Bart explained why good documentation matters to ourselves and to other developers who want to use our code, and he also explained that using an automatic document generator like JSDoc could help make it easier for us to write good documentation and to keep it up to date more easily.
In this week's installment, he starts to show us how to actually write JSDoc comments in line with our code. He explains the different elements of JSDoc comments and demonstrates how his own doc comments evolve as he figures out what he's trying to do. I really enjoyed this installment and his example is perfect for us nerds.
I highly recommend you follow along in Bart's fabulous tutorial shownotes at pbs.bartificer.net
As we embark on our journey to create a JavaScript module for the strong, memorable password generating service XKPASSWD, Bart explains the importance of creating good documentation. That sounds super annoying and tedious, and it is, so Bart explains why a good documentation generator will be our friend. He outlines the two distinctly different users of our documentation: those of us who will be helping to create the code itself as part of the community project, but also for the people who will be users of our JavaScript module. Those users will be interested in how to take the module and embed it into a web page to generate passwords, or to create an Alfred scheme and more. These two different users will have different requirements, and yet our documentation generator can fill both needs without unnecessary extra work. This isn't the sexiest topic, but Bart does convince me that the tools will help us to have the rigor to do it and not let our human instincts take over and allow our documentation to get out of date.
You can find Bart's fabulous shownotes at pbs.bartificer.net
Bart Busschots had a vision that certain things we would learn in Phase 2 of Programming By Stealth would be taught by guest lecturers. I thought he was bananas that this would work, but Helma Van der Linden, also known as Helma from the Netherlands stepped up to teach us about coding linters, and specifically ESLint.
In this installment she explains what linters are, and why they're useful. Even though she's not technically fond of them, she believes in linters because of what they can do for a coding team. Once she sells that idea, she walks us through how to install ESLint inside the development environment VSCode. From there she explains style guides, and shows us how to install and use the very popular airbnb style guide. She gives us tips on usage and even how to override the linter's demands.
I think it was incredibly courageous to fill Bart's shoes, and she did a fantastic job both in the podcast and in the detailed written show notes over at bartificer.net
This installment of Programming By Stealth could probably have been two segments but all of us are itching to get moving quickly so we decided to power through. In the first part of the installment, Bart introduces us to JavaScript modules by giving us a bit of a history lesson on how they've evolved. If you're brand new to modules, this will be interesting but not essential. If you have history with them though, you'll definitely need to pay close attention to understand what's changed.
Then Bart gets into the details of how modules work. He explains how JavaScript modules export variables, functions, and classes and how there are named exports and default exports and how the syntax differs. What fun would learning about exports be if he didn't tell us how to import variables, functions and classes into our code for when we use these modules? We also learn about module specifiers to make it all go.
Finally, Bart takes us through three worked examples where he creates some JavaScript modules that exercise everything we just learned.
It's a long episode but as always, Bart's excellent show notes at pbs.bartificer.net
As we launch full steam into Phase 2 of Programming By Stealth, Bart Busschots introduces us to the Node Package Manager and Node itself. Unlike our mini-series within a series for Git and Chezmoi, Bart isn't going to do an exhaustive walk through NPM and Node. Instead he's going to teach use what we need as we go along. In order for that to make any sense at all, in this installment, he explain to us at a high level Node and NPM are, and what problems they solve.
This lesson isn't all theory though, we actually get to use Node and NPM to build a tiny, self-contained JavaScript app. I had great fun in this installment and Bart's always fabulous tutorial shownotes are particularly well-written this time. You can find them over at pbs.bartificer.net/...
At episode 700! of Chit Chat Across the Pond we take Programming By Stealth into what Bart is calling Phase 2. We've learned a great deal about the client side of programming and we're now going to move to the server side of the web. As Bart described Phase 2, I realized that it's as though we've finished out undergraduate work in computer science, and we're entering graduate school.
That observation is not based on the concepts being harder, but rather because we are going to work as a collective to help our professor on a project that's near and dear to his heart. Bart created the fabulous web-based password creation tool at xkpasswd.net many years ago, in fact so long ago that it's on a very creaky set of tools that have been deprecated and the entire service will die if it doesn't move onto modern tools.
This will be a great excuse for us to learn to work on the new tools as Bart is forced to learn them and at the same time we will be enlisted to help him with the development of the new and improved xkpasswd.
I was really excited as I listened to Bart lay out the future of the next 100 or so episodes and everything we're going to learn. Whether you've been working alongside the rest of the listeners since Programming By Stealth 1, or whether you're a seasoned programmer who'd like to learn the new tools like Bootstrap 5 and PHP 8, I think you'll have great fun with the next phase of Programming By Stealth.
You can find Bart's strategic plan for Phase 2 laid out at bartificer.net
In this final episode of Programming By Stealth before we launch into the back end of web development with PHP, Bart finishes his miniseries on Chezmoi to manage dot files. In this installment he teaches us how to effectively manage our dot files on multiple computers using templating to ensure that the correct settings end up on every computer.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net/...
Bart has been really excited to teach this next installment of Programming By Stealth where we really dig into learning about Chezmoi templates, including learning functions and arguments, how to declare variables, looping over arrays, and learning the sprig utility functions to extend Chezmoi. I thought he was going to jump out of his chair he was so happy to teach pipelines which are a grand way of embedding function statements in a way that is very human-readable.
This is our penultimate installment on Chezmoi, where next time we'll be learning how to manage our dot files across multiple computers where not everything is the same between computers, but much of it is.
You can find Bart's fabulous tutorial shownotes to follow along at pbs.bartificer.net/...
In this week's episode of Programming By Stealth, Bart Busschots continues his instruction on how to use the open source tool Chezmoi to manage our dot files, those hidden configuration files on our Macs. In this installment, Bart teaches us how nearly effortless it is to sync our Chezmoi-managed dot files up to a private repo on GitHub. Seriously, it's like 2 steps.
Bart then teaches us how Chezmoi supports templating. When Bart started to describe it, I said, "Oh! It's just like mail merge in Microsoft Office!" He laughed, and said he hoped I would say that.
With Chezmoi, let's say you have your email address in a bunch of your dot files, and you need to change it to a different address. If you use Chezmoi's templating feature, you can create one file with your email address and in every dot file you reference that address, and only have to change it in one place. Bart walks us through a couple of worked examples to help us see exactly how it works and get a little practice.
The next episode of Programming By Stealth will end this mini-series within a series, and if Bart's work manages to finally slow down to where he can get some good thinking time, we should start up learning about PHP shortly after that.
As always you can read along with Bart's spectacular tutorial shownotes at pbs.bartificer.net/...
In our previous installment of Programming By Stealth, Bart introduced us to Chezmoi, an open source tool to help us manage dot files, those hidden configuration files that get created on our Macs. Configuration files contain information about how we like our Macs configured, including where to access our ssh keys and our preferred command line editor and more. If we move between computers it would be nice to have the same configuration, or if we do a clean install it would be great to be able to have these dot files in place on our newly-formatted machines.
He teased us last time though but just introducing us to Chezmoi and not letting us do much. In this installment he lets us take Chezmoi out for a spin. We edit an environment variable to set our preferred text editor, and then use Chezmoi to talk to Git to add and then commit those changes. Along with more changes and actions with Chezmoi, Bart works hard to cement the terminology of Chezmoi because without it, it's easy to not realize what Chezmoi is doing under the hood and it could cause problems in the future.
You can find the shownotes for this episode at pbs.bartificer.net/....
As we've become nerdier while learning from Bart, we had started to add hidden configuration files to our Macs and PCs. On the Mac, these configuration files hidden by default by putting a dot in front of them, and hence they are called dot files. Maybe you've stored your ssh keys, or in our Git series you created a user-level gitconfig file, or perhaps you've installed VS Code or Sourcetree which also add hidden configuration files.
In this installment of Programming By Stealth, Bart explains the problem to be solved of how we manage these configuration files if we use multiple computers or migrate to a new computer or do a nuke and pave. He lays the groundwork for why he loves the dot file manager called Chezmoi from chezmoi.io.
The installment is a bit of a tease because after learning why we want to have a dot file management tool and why Bart favors Chezmoi for the job, he only lets us install it and run two commands before he says, "And next time we'll start to use Chezmoi."
A few weeks ago I told Bart off the air that when he was done with his mini-series within a series all about the version control system Git, I'd like a few minutes with him offline so he could explain how to ignore files in Git. I knew there was a way to do it but he hadn't covered it so I assumed it was just something quick he could explain to me. His reaction surprised me, he said, "D'oh!" because he realized that this is a _very_ important part of using Git and that he would definitely dedicate an installment to it.
So this week Bart teaches us how to use .gitignore to tell Git _not_ to track changes to files and folders. He explains that there are files your computer or even your code editor may be creating that you don't want Git to track, and of course there all of the dummy test files we as humans create that would not be something we'd want to share with our co-workers or fellow open source contributors.
I was nervous about using git ignore because I understood it relied on patterns, and I thought that would mean something along the lines of using Regular Expressions, which are kind of daunting. I shouldn't have been worried, .gitignore patterns definitely don't require any heavy lifting.
I was really looking forward to this installment and it didn't disappoint.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net/...
As promised, Bart takes us through the final step in our GitHub journey - learning how to contribute to an open source project. He explains three open source scenarios: using someone's code exactly as-is, using their code with a few customizations of your own, and finally the most interesting scenario, customizing the code and contributing your customizations back to the project.
When he gets to the final scenario, he gives us a way to practice these newly-acquired skills, and it's something he's wanted to do for a long time. He's created a gallery for all Programming By Stealth listeners to contribute their work they've done in the various challenges we've worked in Programming By Stealth. If you have your code from the challenges for Conway's Game of Life, the number guessing game, the currency converter, the currency grid, the world clock or the time sharing clock, we'd love to have you contribute to the PBS gallery to show off your work.
Bart explains that the GitHub Pages he's created will allow us to fork his code, make our own changes, and then create what's called a pull request to get them accepted into the official PBS Gallery at gallery.pbs.bartificer.net. I worked through the process for one of my projects and it was definitely a learning experience, which is the whole point of Programming By Stealth.
Bart's fantastic tutorial shownotes are availale at pbs.bartificer.net/...
In this installment of Programming By Stealth, Bart Busschots teaches us how to use a free service of GitHub called GitHub Pages. This service literally gives you free web hosting for the web apps we've learned to make in Programming By Stealth. Bart starts by explaining to us the difference between static and dynamic webpages, and web pages created by static site generators like Jekyll which generates GitHub Pages.
It's trivially easy to create a GitHub Page from an open GitHub repo (literally three clicks in the interface) but it's really important to understand what you're doing when you take advantage of this service. We'll learn what you can do and what you can't do and what you could do if you choose to dig deeper into the woods on how to use Jekyll to generate GitHub Pages.
I'm really excited to learn about GitHub Pages and how easy it is to host all of the web apps we've created in this series.
You can find the shownotes at pbs.bartificer.net/...
In this week's installment of Programming By Stealth, Bart teaches us how to use GitHub as a public repository for our code, or for anything we write for that matter. He reviews whey he chose Github, and then we dig right in. He does explain the benefits of using SSH to access Github instead of HTTPS, and if you haven't set up SSH keys before or you're rusty on the topic, he includes links to our sibling show, Taming the Terminal where you can learn how to do it.
We create a new repo from scratch in Github on the web with a README file and a license, and then we get to use a command line version of Github called gh. With gh we pull the repo down from Github, we edit the files, we commit them locally, and push them back up to Github all from the command line. We then flip the tables and from the command line create another repo directly on Github, create some files, set them up to track and push and pull again to prove it's working.
It's surprisingly easy and simple. Bart teases us with the next episode where we'll learn how to create a website using Github pages, which will give us a nice place to host our web apps for free. You can follow along with Bart's fabulous shownotes at pbs.bartificer.net/...
In previous installments of our Git miniseries within a series in Programming By Stealth, Bart taught us how to work in Git standalone on one computer, then how to work as one developer with multiple computers. In those installments he taught us the necessary commands and their importance in the Git scheme of things. In this installment he talks about how and where to work with a team in Git. We learn about the plethora of options from free to full enterprise-size Git-as-a-service, and why he'll be focusing on Github for the future. He explains how important it is to set up conventions for your team (before you start) for things like coding styles, development paradigm and more. There's no coding in this episode as it's more philosophical than other episodes.
You can find Bart's fabulous shownotes over at pbs.bartificer.net/pbs115.
When Bart started this mini-series within a series on using Git for version control, he explained that our journey would be in three Phases. Phase 1 was the section where we learned about local repositories, and Phase two was dedicated to learning how to have multiple repositories just for ourselves. In this lesson, we finish up Phase 2 by learning how to push and pull changes from our imaginary desktop to our imaginary NAS to our imaginary laptop and back. I slowed down the class a few times with some confusion I had, but Bart always claims that my confusion often helps other people who might be hung up on the same thing. I enjoyed myself immensely, even when I was confused!
We are about to enter Phase 3 where we will learn how to collaborate with others. We'll be doing this collaboration using Github, because it's pretty much the defacto home for most open source projects. When you're done listening to PBS #115 and studying the shownotes, you might want to get yourself a Github account so you can be ready for the next lesson.
As always you can find Bart's fabulous tutorial shownotes for this lesson at pbs.bartificer.net/...
We continue on our journey to learn how to use Git to do version control as a single person, but this time with multiple devices. As Bart says during this episode, "Who is learning to program here who doesn't have multiple computers?" We've learned how to push our changes to a single separate repo, but we had to always say what branch we wanted to push to what branch on the origin. In this installment we learn how to tell Git to _track_ our branches so they stay in sync without us having to tell Git every time which branches to push where. We also learn how to make sure our annotated tags get pushed as well by setting a single repo or all Git repos on our computers to push our tags. Bart leaves us with a big tease at the end. We learn how to clone a repo in preparation for having two computers accessing the same code in Git with a primary source acting as the go between for them.
Last time on Programming By Stealth, Bart introduced the concept of remote repositories, also known as remotes. It was one of those episodes where we learned a lot but didn't get to apply what we learned. In this week's installment we get our hands digitally dirty as we create a _bare repository_ (a repo with no working tree), and declare it to be a backup of our local repo. We learn how to fetch and view remote branches and tags, how to push everything to the remote, and then after making some changes, push them to our remote backup. We're still in a bit of a sandbox as we do all this on one computer inside a couple of local folders, but the lessons exercise our new muscles to get ready for the big leagues.
Bart's excellent tutorial show notes are as always available at pbs.bartificer.net/...
[audio mp3="https://media.blubrry.com/nosillacast/traffic.libsyn.com/nosillacast/CCATP_2021_04_03.mp3"]
mp3 download
In this next installment in our mini-series on learning Git, Bart Busschots gives us some foundational knowledge on how to work beyond being one person with one Git repository.
He starts by reinforcing what he's explained before, that Git is a peer-to-peer technology, which is hard to wrap your head around if you're used to client-server relationships. He walks us through three scenarios to explain how every "actor" gets a repository and why. Then he explains the jargon of "local" vs "remotes". It's at this point that my head started to hurt, but Bart claims this is where I'm value-added to the podcast. I ask all the questions you might have, and I suspect many more than you have. Bart sticks with me and makes sure I fully understand.
You can find Bart's tutorial show notes at: pbs.bartificer.com
In this installment of Programming By Stealth, Bart teaches us how Git can help us when we forget to switch to the correct branch before starting to make changes to our code. We're only human, and we will forget, and Git's stash command allows us to set our changes aside, switch to or even create and switch to the correct branch and then apply our changes. His explanations and repetition in the exercises really cement the knowledge. As a bonus tip, he teaches us how to make shell variables inside the Terminal which will help us with some of the repetitive typing in the future.
Bart's tutorial shownotes are at pbs.bartificer.net/pbs111
In this installment of Programming By Stealth Bart teaches us how to deal with conflicts in branches of our code. He has been purposely only changing one thing at a time before now, but it's time to face the reality of when two branches change the same line in the same file. I've been terrified of this topic for a long time, but Bart shows us how easy it is to see exactly what the conflict is, how you can back out of merging if you make "a pig's breakfast" of it, and how to resolve your conflicts without fear. It's not nearly as terrifying as I thought it would be.
You can find Bart's tutorial show notes at pbs.bartificer.net/...
And if you learn a lot from Bart, please consider becoming a patron of his by going to www.patreon.com/...
We continue our mini-series within a series learning the version control system Git. We learn two methods to enhance our branching strategy. First, we'll walk through some basic principles on how to number our released versions of our code. From there we'll explore three types of changes that would cause a change in our release version: fixes, new features, and breaking changes. Each of these types of updates to the version of our code can be articulated with Semantic Versioning, also known as SerVer. This numbering convention informs users of our code on the meaning of each release. Finally, we marry these concepts by creating meaningful commit messages using another convention called Conventional Commits. Not only can a user of our code see at a glance what happened in a specific commit, documentation can be auto-formatted to explain the commits.
There's not a lot of hands-on in this lesson but as a structured person, I really appreciate these conventions and why they're important.
You can find Bart's tutorial shownotes at pbs.bartificer.net/...
In this installment of Programming By Stealth, Bart Busschots continues on his series within a series explaining the version control system Git. We advance in our branching strategy by working several commits on our dev branch and then learn to use a merge commit to bring only the final commit into the main branch, leaving the half-working intermediate commits to exist only on the dev branch. This process illustrates the need to learn about tags, both light-weight and annotated. Once we understand how these tags work and their importance, we evolve our PBS branching strategy one step further.
Bart's tutorial shownotes are available at pbs.bartificer.net/...
This week in our miniseries on learning the version control system Git, Bart dips our proverbial toe into branching. Branches allow us, as developers, to work on bugs or feature enhancements in a separate place from our stable code, and only merge the code back in when the bugs are squashed or the features are stable.
We don't get much practice in this instalment, but rather Bart talks to us about the idea of having a strategy for when to branch and how to name your branches in order to prevent chaos. He gives us some simple and yet difficult to adhere to strategies and then takes us through more rigorous strategies that will actually be easier to follow. He emphasizes that he's not telling us which strategy to follow, but rather to have a strategy.
We do a few small examples from the command line, but we get to open our Git GUI clients, like GitKraken and Sourcetree and see how the commands we're typing are graphically represented in the clients. It's a good illustration of what Bart has been promising us – that the GUI clients are doing exactly what the command line is doing.
You can find Bart's tutorial shownotes at https://pbs.bartificer.net/pbs107. And if you'd like to support Bart on Patreon, go to patreon.com/ltpod.
As we continue to learn Git from the command line for version control, Bart teaches us some tricks to travel through time. First he shows us how to view more compact Git logs so we can just see a shortened hash and the first line of our commit message. Then he shows us how to pick out a single commit from the past and see what changed. Then he shows us how, with surgical precision, we can go back in time and get a single file or even just the changes from a specific commit and bring them forward in time. It sounds head bendy but I could immediately see the usefulness of going back in time and grabbing some code that was working well and bringing it forward.
You can read Bart's tutorial shownotes at pbs.bartificer.net/...
Bart takes us on a time traveling adventure with Git. By using commands like git diff we can see changes over time, but we can actually see older versions of the code in a couple of ways. Using the archive command we learned out to pull just the files at a certain point in time (without the history) and the more terrifying checkout command that creates a "detached HEAD"! Bart even explains why that phrase was introduced and what it actually means. This was a fun lesson and a good foundation for what we'll learn next time, when we'll learn about stashing and branching to control the past and future.
In our next baby step in learning to use the version control system Git, Bart teaches us how to track changes. We start by doing a bit of housekeeping, especially for Mac users to set Git to always ignore those pesky .DS_Store files. We learn how to stage and then commit a simple change, then we stage and commit multiple changes and even learn to see the differences in our staged files from the database all from the command line.
While we all think we're capable of making one structural change and then committing our changes, Bart knows that it isn't going to happen. But there's still a way to follow Helma's advice to "commit early and commit often". Bart teaches us how to divide the changes we inevitably make into separate commits with separate comments so we can figure out what we did later.
I enjoyed this installment because I could tell it was laying a very important foundation of understanding. You can follow along with Bart's famous shownotes at pbs.bartificer.net/...
- allison@podfeet.com
- Support Bart on Patreon
- Join Our Slack
After some quick revision from the previous episode, Bart explains how Git commands work with their subcommands. We start by looking at how to configure Git and the differences between local, global and system-level settings. Then we create our very first repo with an exciting README file, and we commit the file to our repo. It's a fairly simple lesson while laying down a good foundation for all future work.
You can find the shownotes for this installment at PBS 103 of X — Getting Started With Git
- allison@podfeet.com
- Tesla Affiliate Link
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/paypal
In our last Programming By Stealth we learned about the concept of version control, and the evolution from client/server version control to peer-to-peer version control and the creation of Git. In this installment we start learning the fundamental concepts of Git. We learn about the database, the working copy, and the index and understanding the difference is critical to effectively using Git. We also dig into the Git database and begin to learn the terminology inside it, which oddly uses normal English words but those words might not mean what you think they mean. We gain an understanding of why Git uses SHA1 hashes but not for encryption. We start to get into the power of Git as we learn about commits, staging, stashes, and tags.
We didn't get to play with Git yet but the challenge is to install Git and if you want the extra credit, choose and download one ore more Git GUI clients.
It's time to take on a new subject: version control. As Bart explains in this week's episode, version control allows you make changes in your code and roll the changes back. This gives us the freedom to experiment and if an idea doesn't pan out, get back to where we started. Bart explains some of the origins of version control, starting with client server systems and then tells us how peer-to-peer version control has become the standard from industry to open source.
Bart explains how the version control system Git was created and how it proved itself worthy of becoming the standard. There's not a lot of heavy lifting in this episode but Bart promises that future episodes will be challenging as we get into how to actually use Git.
If you like Bart's work, please support him by going to lets-talk.ie and becoming a Patron.
In this positively _delightful_ episode, Bart and I celebrate 100 episodes of Programming By Stealth. When we hit 99 instalments, Bart declared that for 100, there should be cake! So I got Bart's darling beloved to deliver him a piece of cake right as we started, and Steve delivered one to him. To say that Bart was surprised and delighted would be an understatement!
This episode is entirely dedicated to us describing our solutions to the Time Sharing challenge from PBS 96, and to explaining what we learned while working on the assignment.
You can view Bart's working solution at this-ti.me/ and you can view Allison's working solution at podfeet.com/time-shifting-clock
This week our guest is Dr. Helma van der Linden from the Netherlands here to talk about how she created the Taming the Terminal book using all Open Source software.
On the NosillaCast I talked a lot about the book but I should probably give an explanation for the Chit Chat audience. Bart Busschots and I created the Taming the Terminal podcast and for this series on learning the macOS (and Linux) command line, Bart wrote a spectacular set of tutorial shownotes on his website at bartb.ie.
I had a dream for many years to make Taming the Terminal into a book as a surprise for Bart, but my few attempts to do it failed spectacularly. Around Easter, I mentioned my dream to Helma and she said, “I bet I could do that!”
I don’t expect anyone to learn from this discussion how to do what Helma did, but rather to learn what’s possible and how cool it was that Helma put these pieces together. Below are the rough shownotes we used for our discussion, included so that you would have the links to all of the tools she explained in the episode
Downloads of the book can be found at podfeet.com/tttbook and the GitHub project for Taming the Terminal can be found at github.com/bartificer/taming-the-terminal. You can communicate with Helma through our Slack community at podfeet.com/slack where her handle is @Helma.
Bart and I are taking a few weeks off from Programming By Stealth as we do every summer but we'd like to encourage you to check out the new Taming the Terminal episodes we'll be publishing instead.
This week Bart Busschots brings us the penultimate JavaScript installment of Programming By Stealth as he brings us part 2 of building with classes. This wraps up our third look at Object Oriented programming in JavaScript. We learn about the concept of inheritance, and how it allows us to build classes that inherit attributes and functions from parent classes. This allows us to eliminate code duplication which Bart explains is called a "bad smell".
You can find Bart's tutorial shownotes at pbs.bartificer.net/pbs99.
In this episode of Programming By Stealth, Bart explains one single concept, that of "Has-A". This is part 1 of 2, where next time we'll learn "Is-A" which is about inheritance. These both sound like odd terms but they're part of what makes object oriented programming so powerful. Bart spends 90% of the time going through a worked example which not only explains how classes can have instances of other classes as properties, but also how classes can be more specific versions of other classes. Along the way, I think he achieved his goal of cementing the foundation of getters and setters and Class functions and Instance functions. We'll see if I can use them in anger on the homework though!
You can find Bart's tutorial shownotes at pbs.bartificer.net/...h
I'm not going to lie to you guys, this episode of Programming By Stealth was pretty rough for me. It builds on the foundation Bart laid in PBS 95 where he introduced Getters and Setters and it was pretty clear that this previous lesson had not sunk in for me yet. I'll definitely have to go back and study PBS 95 a couple more times and get a chance to practice this Getter/Setter concept before the penny will drop. Hopefully you understood it better than I did the first time through!
In any case, in PBS 97, we extend that knowledge to learning about class data attributes and functions. We'll learn the "static" nomenclature, which is used to mark attributes and functions as belonging to the class rather than the instances of a class.
Bart spends most of the lesson on a worked example using emoji to create what he playfully calls a Nerdtouche, as a head nod to the cartouche used by Egyptian Pharoahs. And yes, he manages to work the poop emoji into this lesson.
You can find Bart's shownotes at pbs.bartificer.net/pbs97.
This installment of Programming By Stealth is a solutions show all about the clock assignment from PBS 92. Bart's been quite busy this week designing an entirely new distance final exam system for the university where he works so he asked if I'd take on half of the content by presenting my solution to the clock challenge. I have had an absolute blast on this assignment so I gladly accepted. I walk through my approach and some of the challenges I met along the way, and then Bart complements mine by talking about a few things he did quite differently. We both had a great time and I think Bart even learned something from me at one point.
You can find Bart's fabulous tutorial shownotes at pbs.bartificer.net/pbs96.
This week Bart explains how to give our JavaScript classes better data attributes via a very powerful JavaScript feature: getters and setters. On my first read through the notes for the episode, my head was spinning a bit, but Bart explains this so well using concrete examples (like a circle with a radius) that I think he got it through to me. When I told him up front that I struggled a bit when reading the shownotes, he said that this is the "pointy end" which I think meant that it was a difficult concept so I felt a little better about it.
In the end it made a lot of sense and I see the reason for the tools he explained.
I highly recommend you read Bart's terrific tutorial shownotes at pbs.bartificer.net/pbs95 as you listen along.
In the early days of Programming By Stealth, Bart tried to explain JavaScript classes, objects and instances. He talked about it in Installment 17 before ES6, and then took another run at it in installments 27-31. But it never felt to Bart like he had explained it in a way that made it clear.
In installment 94, Bart finally nails it. I told him the shownotes for this installment might be the best he's ever done. Everything he explains is clear and concise, the examples are superb, and we get to say Hoonyaker a lot. Instead of being frustrated and confused, I was smiling through all of it because I finally get it. I also told him that I feel far less stupid than I did before because I always thought it was my failing that I didn't get it. I enjoyed this so much I drew Bart a picture of what he'd taught and he said I nailed it!
You can find these legendary shownotes at pbs.bartificer.net/pbs94.
In this episode of Programming By Stealth, Bart takes us through the last "hat" that JavaScript objects can wear: encapsulation. As Bart walks us through the problems encapsulation solves using a funny NosillaCast-specific example, he shows how the code becomes reusable and sharable with encapsulation, and even more readable.
You can read the tutorial shownotes as you listen at pbs.bartificer.net/...
- allison@podfeet.com
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/amazon
- podfeet.com/paypal
CCATP #630 for March 14, 2020, and I'm your host, Allison Sheridan. This week our guest is Bart Busschots with PBS 92 of X in which he walks us through his solution to the assignment from PBS 89 to create a grid of currency conversions.
He doesn't go through his code line by line, but rather gives us the big picture of his process. Most of the time he spent on the solution was actually in refactoring his code because he decided to preload the data rather than fetching it repeatedly on-demand. I loved it when he referred to his original work as "Organically-grown Weasley-kind of code".
He also explains how he used both coercion and assertion to do his error handling and why. Eventually he got to start working on the grid and he walks us through how he cracked that problem. It was great fun as always and we have a new, six-week challenge to build a world clock.
You can find his full tutorial shownotes and download his solution at pbs.bartificer.net/pbs92
This week our guest is Bart Busschots with an installment of something he's calling Programming By Stealth-adjacent. It's not part of the regular series of Programming By Stealth, and yet it's not technically very "light" in terms of the chit chatting. Since neither podcast is the right place for it, I've decided to put it in both podcast feeds to be wrong twice.
Bart walks us through how to create Quick Actions with Automator (also known as Services) to do some simple but very useful text manipulations using a smidge of JavaScript. Even if you don't want to write these Quick Actions yourself, you can download his services from his Github repo where he's put them up as open source: https://github.com/bbusschots/macos-quickaction-text.
You can see how Bart created this in his blog post at www.bartbusschots.ie/...
Bart takes us through the penultimate hat JavaScript wears and that's Regular Expressions. Luckily since we haven't talked about REs in ages, he reminds us of the syntax for Regular Expressions literals in JavaScript first and then he takes us through three common uses for Regular Expressions. We joked around during this episode at how many times I said, "That makes sense!" Bart said it was music to his ears, and I say this was a very intuitive lesson considering how arcane Regular Expressions are in their syntax.
Bart's tutorial for this episode are available at pbs.bartificer.net/...
Hope you enjoyed getting the little extra Tidbits episode this week. In this installment Bart continues our on-going mini-series looking at each of the proverbial hats JavaScript objects wear. Bart explains the concept of JavaScript wrapper objects that allow you to access properties of otherwise property-less primitives. It's pretty magical and I only got lost for a little while as we brushed the cobwebs off my memories of prototypes and such.
Bart's shownotes for this episode can be found at pbs.bartificer.net/pbs90
Bart explains how alert listener @lbutlr on Twitter found a mistake in Bart's math and he walks through how he figured out what was wrong and what we can all learn from it. Bart's explanation can be found here:
bartbusschots.ie/...
In this week's installment of Programming By Stealth, Bart explains his new plan for both the content of PBS and the way the shownotes are created and presented to you. Bart has noticed that because we put a challenge solution and new content into the same show, the solution gets short changed. That's a shame because there is so much he can teach by explaining the "whys" behind his design of his solutions.
The new plan is to have the challenge solutions be standalone shows, and then the new content will be standalone shows as well. We'll be having more time to do our challenges with this new plan as well. I'm excited about this new plan because I've enjoyed the extra time we've had with our currency converter challenge, allowing us to enhance our solutions and be more creative.
Bart is also completely rearchitecting all of his web presence, including his Programming By Stealth show notes. His new online presence will be at his site, bartficier.net and PBS will now be at pbs.bartificer.net. That link is actually to a GitHub page. I know that sounds crazy and Bart is going to tell us more about it, but it will allow him time to be much more creative and spend less time faffing about as a system admin.
With all that said, you can find the shownotes to this week's installment at pbs.bartificer.net/...
Bart is nearing the end of his mini-series recapping al of the different hats JavaScript objects wear, doing a lot of redux to cement the concepts that have been spread over so many lessons. He takes a really interesting approach this week to his teaching. He explains a concept and then instead of having a contrived example, he shows us exactly how that concept works in action in his homework solution from PBS 85. His solution to the homework assignment is, of course, beautiful and elegant. Beautiful he gives credit to Bootstrap, elegant he would probably give credit to jQuery.
I am really enjoying these redux segments because they cement things that were still wobbly, or perhaps even gone from my memory. Each time through I'm finding I understand how to even categorize the information in my brain. I explained to Bart that I think he's actually changing the way my brain is wired now.
I'm not going to lie, this episode of Programming By Stealth with Bart Busschots was a bit head bendy. Bart explains JavaScript Iterator Objects and Generator functions but without his excellent examples I'm certain I would never have been able to get the concepts to even slightly congeal in my brain. Iterator Objects and Generator functions are some of the joys of ES6 and have great value.
That value is demonstrated in the succinctness of the code Bart writes for us to create a Fibonacci series in a beautiful web form. That work, by the way, is a bonus challenge if you're done with your homework from the previous episodes. As you listen along, if you hear us yelling "spoiler alert" and making alarming noises, that's when Bart's solution to the challenge is about to be described. It's a rare instance where I actually let you have one chapter mark in Programming By Stealth so you'll be able to jump back to the solution after you're done with your own solution.
Bart continues his redux and new information by circling back through Objects as Arrays in JavaScript. I don't know about you, but I get a lot out of the redux episodes because it cements in place concepts that were a bit wiggly before he goes through it again. The one new concept he goes through is Array Destructuring which sounds ominous and destructive but which allows us to dive into arrays and create new and more interesting arrays.
Bart also debuts a new way he's providing the content for the lesson. If you still want to download the zip file with all of the example files, you can, but you can also view the source code and view the html in a browser with a Github link. By the way, the zip file is now living on a content delivery network. This is important to note if you're coming in from Safari with the more recent security updates because it will prompt you to agree to downloads from this new URL.
Bart's fabulous tutorial show notes (including the links to the source for this week's episode) are available at bartbusschots.ie/...
- allison@podfeet.com
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/amazon
Bart has been noticing that there are a few key features in JavaScript that haven't ever really congealed for me and is circling back in hopes of firming them up. The other reason he's going over these topics is that new options have been created since we first covered them. The first of these subjects is objects as dictionaries. I confessed to him recently that I've never successfully done a for loop on my own yet, so we slow down a bit during that part but we speed up again into what are actually more challenging topics. We had a lot of fun doing this episode (even when I was stuck!)
At the end of the show I suggested a palate cleanser, which is a feature of his Security Bits segment he does for the NosillaCast. I found an awesome tweet by developer Sarah Dresner (@sarah_edo: "Apparently the only cure for jetlag is to make SVG animations of farting rhinos with the new @greensock API 💨". Of course I had to follow that link, and it was awesome. It is literally an SVG file of an adorable little rhino trotting along and tooting. After Bart and I got off the air we took advantage of the fact that she'd posted the farting rhino on codepen.io so we view the html, css and JavaScript to see how she did it. I know this is silly but that's what makes it so awesome.
Bart finishes up our first exploration of Bootstrap 4 with a look at one its most versatile components, the so-called Card. This is one of those components that’s so generic it’s hard to describe, but once you learn about it you’ll start seeing it all over the web. Cards really are ubiquitous!
It’s important to stress that while we’re wrapping up our exploration of Bootstrap 4 with this installment, that does not mean we’ve come close to covering every feature this impressive library offers. Instead, the aim was to cover the big-picture items, and leave you with enough experience to be able to learn the rest independently by reading Bootstrap’s excellent documentation.
Bart's tutorial show notes can be found at bartb.ie
- allison@podfeet.com
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/amazon
We're back after a summer hiatus (where Bart was working too hard) with a new installment where we attempt to dust off Allison's brain and learn about two new promise-related keywords, async and await. Both of these keywords were actually added to the core JavaScript language, so this doesn't happen that often.
With async and await, we can actually get away from doing promise chains and create much more readable code while still being able to control parallel and in series tasks. Bart had to drag me along a bit in this one but I saw the beauty of it when we were done.
Bart's fabulous tutorial shownotes can be found at PBS 82 of X — Async & Await : Bart Busschots.
In this installment of Programming By Stealth, Bart teaches us how to use Promises, with a capital P to get promises when we already know the value we want to supply. That sounds funny but it will make sense in context. Then he shows us how we can control parallelization of promises using Promise.all(). It's a very sensible lesson, and not brain bendy at all. (I really like those.)
Please consider supporting Bart's hard work for us via Patreon at patreon.com/ltpod
Bart's fabulous tutorial shownotes are available at bartbusschots.ie/...
- allison@podfeet.com
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/amazon
In the very first Programming By Stealth supplemental episode, Allison interviews Dorothy Rendon, the programmer behind the PBS Index. If you haven't seen it before, it's an index that Dorothy has created for the Programming By Stealth students to helpt them find key topics in Bart Busschots's fabulous tutorial shownotes.
- allison@podfeet.com
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/amazon
Bart Busschots (successfully) explains the concept of JavaScript promise chains. It's a rough ride because of the subject itself, but he gets us there through his care and detail in explaining the concepts and of course his great examples. When he's done, you'll know how to chain promises together, you'll understand what data is passed through, and you'll understand why he says, "Don't have unhandled rejections, it's just not nice."
You can find Bart's detailed shownotes at bartbusschots.ie/...
- allison@podfeet.com
- podfeet.com/patreon
- podfeet.com/slack
- podfeet.com/facebook
- podfeet.com/amazon
Bart has been _promising_ us Promises for ages now and he finally fulfills his promise by explaining thenables. Promises are a tool to get us out of "callback hell", which we experienced a while back. I think he made us suffer through that so we'd appreciate Promises. In this episode he shows us the beauty and elegance of the concept but leaves us wanting more. Bart spent a lot of time trying to get the shownotes and his narrative to take this rather abstract concept and make it concrete, and I think he did a grand job of it.
Bart's amazing tutorial shownotes are available at bartbusschots.ie/...
Bart Busschots and I both had a great time doing the challenge this week. In this week's installment Bart takes us through his homework not in a detailed step-by-step method, but rather he goes through some major structural ways he created his code. He digs deep enough to explain why but it's a great lesson on building code that's easier to debug and more fun to write. I got to be the tester of his code, and as I suggested improvements he decided he needed to use Bootstrap Popovers. He walks us through how they work and I have to say they're really slick. Then he introduces us to a super intuitive JavaScript library called is.js that solves will simplify our code. I asked Bart if he could back up 2 weeks and show me is.js BEFORE I did last week's homework!
As always, Bart's awesome tutorial shownotes are available bartbusschots.ie/....
Bart Busschots starts this week's episode with a great refresher on what a callback actually is (because I have remained mystified by the term). He starts with simple examples and then shows us how we've been using callbacks all along and just didn't realize it. Then he'll walk through the challenge solution and the extra credit. He shows us how there's two paths to "callback hell", one through nested AJAX calls in parallel, and one with them in series (which sounds worse than it actually is. The challenge for next week is super open-ended which terrifies me but I'm sure it will be fun.
In this week's episode, we have another in our series Programming By Stealth with Bart Busschots. We'll spend the majority of our time talking about Bart's solution to last week's challenge. It's a great refresher on the methods he's taught us in the past, all rolled together with our newfound skills with Mustaches and templating. Then we'll get a start on using AJAX with jQuery and what sounds to me like a relatively easy challenge … except for that extra credit bit.
Bart's extensive tutorial shownotes (and I really mean extensive this time) can be found at bartbusschots.ie/...
Join our Slack at podfeet.com/slack and be sure to check out the #pbs channel to talk all things programming.
In this episode of Programming By Stealth we get the foundation to start learning about AJAX. Bart gives us an overview of HTTP that is really interesting. I learned so much that I didn't know about what you can see in a URL. I know this sounds super nerdy but I loved learning about query parameters and HTTP methods and even HTTP request headers and cookies.
In this week's Programming By Stealth, Bart Busschots teaches us the last two concepts in Mustache, one of which is a real head bender and for me at least, the second was almost as hard. The first is how you can add an optional third argument to a Mustache view which is actually a function within a function. It's a very meta concept. The second is the use of Mustache Partials which are templates within templates. I expect you'll follow along faster than I did but I _think_ I got there in the end!
You can find Bart's shownotes for this installment at www.bartbusschots.ie/...
In this installment of Programming By Stealth, Bart Busschots teaches us about Mustache Templates. Mustache Templates are a library that allow you to input any string and output a string. Unlike the template tag for HTML5, Mustaches are not restricted to HTML snippets. Mustache isn't the only game in town but it's Bart's favorite. I found this lesson fairly confusing along the way but when I got to the very end I think I understood it all! There was a key point in his instruction when he said to think of this as being like Mail Merge where you have a form letter and then a separate file that has the info that gets plugged into the form letter. Once he said that it became much more clear to me. Hope that little hint helps you too!
Last time Bart teased us that we were going to learn about the template library called Mustache, but he realized that he needed to teach us about vanilla HTML 5 Templates first. He starts by showing the problem to be solved: how messy and error-prone it is to create HTML elements using jQuery. Then he shows us how templates allow you to create multiple elements via cloning of the templates. The syntax is quite annoying, but I think once we get used to it, it will be pretty easy and efficient to use.
In this week's installment of Programming By Stealth, Bart Busschots spends most of the time walking us carefully through each of the methods he used to solve the challenge from last time. He does a great job of reminding us of things we've learned, in some cases more than a year ago, and showing how they were applied for this particular problem. I'm quite proud of one little thing I discovered that Bart didn't know had been introduced in HTML 5. After he's done walking through the challenge, he introduces Bootstrap Spinners. Spinners are a visual indicator to the user that some operation is going on that will take some time and let them know that things aren't just broken.
In this week's Chit Chat Across the Pond, Bart Busschots is back with another installment of Programming By Stealth. We'll shift gears a bit away from web pages to web apps as we explore the usage and code behind Bootstrap Modals and Toasts. It's a combination of HTML, Bootstrap for styling and JavaScript for actions so it flexes all of our programming muscles.
We wanted to give a special shoutout to Caleb Fong, aka @GeekoSupremo for posting a link in the Podfeet slack to a fabulous cheat sheet for a ton of programming APIs. It's got JavaScript, Regular Expressions, Flexboxes, and lots of other things we've haven't yet learned. You can find the cheat sheet at freeCodeCamp at medium.freecodecamp.org.
And as always you can find Bart's tutorial show notes at www.bartbusschots.ie/...
In Chit Chat Across the Pond we are finally back to a Programming By Stealth episode. In this installment, Bart teaches us how to create navigation bars in Bootstrap. We learn how to make them collapse and expand to different device screen sizes and how to style them to look nice. We learned how to add branding and how Bootstrap makes it do logical things. It was an extraordinarily easy lesson because Bootstrap makes it that easy.
You can find Bart's tutorial shownotes for this episode at www.bartbusschots.ie/...
In this week's installment of Programming By Stealth, Bart Busschots introduces us to how Bootstrap will help us create navigation in websites or web apps. This is using what Bootstrap calls the Nav component. As always we'll learn how to style the navigation using Bootstrap Pills and Tabs. Then we'll take it up a notch and learn about Bootstrap Panes and how to reveal them within Bootstrap Tabs.
As always, Bart's fantastic tutorial can be found at www.bartbusschots.ie/...
In this week's installment of Programming By Stealth, Bart Busschots takes into the land of Bootstrap dropdown menus. He explains the differences between dropdown and selects in HTML, and how there's two different kinds of dropdowns - menus and navigation. The descriptions of how to make the Bootstrap dropdowns takes a while, but when he puts the pieces together, the code is quite sensible.
With any luck at all, I _think_ I have added chapter marks to the show to let you jump from the intro to the homework challenge and then to the new material. If this provides value to you, it would be swell if you sent me a note in some way about it.
HTML 5 gives us form validation for free, but it's not very nuanced. In this installment of Programming By Stealth, Bart will show us how to use Bootstrap to make our form validation a little less shouty and more useful for the viewer. He shows us how to take a little control, how to take a lot of control and how to take supreme control. That last bit scared me when he introduced it but he does a fantastic job of breaking down the building blocks for us. He builds up the form validation in logical steps, using tools we already know (but might have to dust off a bit.)
Chit Chat Across the Pond this week was Programming By Stealth installment 65 of X. This time Bart takes us through Bootstrap Input Groups. These are really cool. Think about a form that has information you have to fill in, but you're never sure what they're asking for. If they ask for money, what currency do they mean? Are you supposed to include the numbers after the decimal or not? With Bootstrap input groups you can put little symbols or words before or after the input field to make it obvious. As with all things Bootstrap, it's not something that can't be done in HTML, but it's so much easier to make them pretty and elegant without being a designer.
In this Programming By Stealth episode of Chit Chat Across the Pond, Bart Busschots teaches us about three more types of Bootstrap Form Layouts. It's not too tough of a lesson and we had a lot of fun working through the lesson. You can find Bart's full written tutorial at bartbusschots.ie/....
Support Bart on Patreon!
This week in Programming By Stealth, Bart Busschots and I spend a fair amount of time going over the homework challenge from PBS 62. The nuances combined with some refresher on how the pieces fit together was something I really needed so hopefully I wasn't alone. The new part of the episode is dedicated to the all-important Bootstrap Button. We'll learn how to turn things into buttons and why you might want to do that, and we'll learn how to make Button Toolbars which are really slick and pretty. We don't have new homework for this week but if you're like me you need time to properly finish last week's homework.
You can find Bart's tutorial and solution to the challenge at bartbusschots.ie/...
Support Bart on Patreon!
This week's Programming By Stealth was great fun. Bart Busschots teaches us how to create a web form using the Bootstrap classes to do the job. He explains how Bootstrap literally insists that we make our code accessible, and how sensible it is to just that. We learn the importance of Form Groups, and how Checkboxes and Radio Buttons are a slightly different type of input to a form and so have their own Bootstrap class. It's great fun and the challenges look like fun too.
At the end of the episode I added what Bart likes to call a Palate Cleanser. I've been following a woman named Samantha Ming on Twitter and samanthaming.com where she posts fun little CSS and HTML tricks. I learned how to make the caret on an input field blink in pink, and how to make regular HTML text on a web page be editable.
Bart's tutorial for this episode is available at bartbusschots.ie/...
In this week's installment, Bart explains how to create two simple Bootstrap components, the Jumbotron and badges. A Jumbotron is a show-case area at the top of a website's front page that shouts out the site's main message and usually has a call to action. Badges are the little bubbles next to titles or within buttons that contain extra information. Often they contain a number, such as number of unread messages, or a short phrase like "New!" or "Best Value". It's a pretty easy lesson and the homework looks fun too as we figure out how to add badges to count the number of open alert windows and add a Jumbotron to our work.
In this week's installment of Programming By Stealth Bart introduces us to Bootstrap Components how we can use jQuery to extend Bootstrap. This is the first baby step into JavaScript with Bootstrap. I'm glad Bart started slowly because my JavaScript muscles are just a bit stiff and dusty. You can find Bart's tutorial over at bartbusschots.ie/.... Please consider supporting Bart's work on Patreon.
Bart takes us back to Bootstrap content, now that we know all about breakpoints. He never told us when we were looking at things like margins and float and the display tag that they are also breakpoint-aware, because we didn't know about breakpoints yet. It's an easy lesson and it's great fun to learn more about how responsive design is done with Bootstrap.
You can follow along with the audio with Bart's awesome tutorials at bartbusschots.ie/...
In this week's installment of Programming By Stealth, Bart Busschots explains Bootstrap breakpoints. Breakpoints allow the designer to define how a web page reacts depending on the size of the viewer's screen. He explains how through some very simple Bootstrap classes, we can allow a semantic tag to be in the "correct" order for screen readers and search engines, and yet have the layout be visually appropriate across all screen sizes.
Follow along with Bart's detailed tutorial shownotes at bartbusschots.ie/...
Things take a turn for the mind-bendy in this installment about Bootstrap as Bart Busschots explains the Bootstrap Grid. He teaches us how containers have rows, rows have columns and the number 12 is really important. In the end he leads me to understanding but it was a bit of a bumpy road getting me there. You'll probably swim right through it without difficulty because of Bart's fabulous shownotes at bartbusschots.ie/.... If you a
We continue learning about how to style our HTML with Bootstrap as we take a look at styling images, figures, and tables. These Bootstrap classes are really easy to use and make such a difference in the look and feel. You can find Bart's tutorial shownotes and the downloads at bartbusschots.ie/....
We finished learning the Bootstrap Utilities last time so this time we get to start learning about continue to learn about Bootstrap moving on from the Utilities into Bootstrap Content. Content is kind of an odd word; it means Bootstrap's styling of regular HTML tags for things like headers, paragraphs, lists and tables. We have a lot of fun playing with our recipes in this episode, learning how to easily style them to be much prettier. Bart's fabulous tutorial shownotes are at bartbusschots.ie/...
In this week's episode of Programming By Stealth, Bart Busschots takes us through the last bit of the Utilities for Bootstrap 4. We'l refer to the WABAC Machine (kids, ask your parents about Sherman and Mr. Peabody) to installments 8 and 9 comparing positioning with CSS vs. Bootstrap. Thenwe'll learn about sizes and float utilities, Flexbox utilities, and Screen Reader utilities. It's great fun and of course Bart has his excellent companion tutorial at bartbusschots.ie/... and you can find Dorothy's awesome index of all things Programming By Stealth at podfeet.com/blog/pbs-index.
We're finally back to a new episode of Programming By Stealth after a few weeks chatting with different things like GDPR and DNS with Bart Busschots. In this installment, Bart starts explaining the Utilities available in Bootstrap. We'll learn how easy it is to use the pre-built CSS styles in Bootstrap to color text, add borders, spacing, text alignment and fonts all with semantic phrases that actually make sense! In an odd bit of luck, Bootstrap had been updated and Bart's code didn't reflect the new version. In most shows, this would be a problem but the change allowed Bart to walk me through how to figure out what was wrong and how to access the Bootstrap documentation to fix it. The best way to learn something is to break it first, or at least Bart and I feel that way.
Bart's most excellent shownotes are at bartbusschots.ie/...
We're finally back after spring break, and we're going to be moving on from JavaScript while we learn about Bootstrap. Bootstrap is a set of open source libraries which provide pre-built foundations for creating responsive and good looking websites. It's an easy episode with easy and fun homework I think you'll enjoy.
Before we got started I talked about a fantastic post Will (aka @beiju) wrote to me to help me understand JavaScript objects better. If you've been struggling like I have or just want a nice reference written in conversational style, check it out at Objects in Javascript Explained (for PBS) – by Will aka @beiju
As our last episode of Programming By Stealth before our spring break, Bart wraps up our Cellular Automaton. He goes through his solution to the PBS 49 challenge first, and then he walks us through three examples of how a user could produce three different representations with our code. He demonstrates how to build a Conway Game of Life, the Maze Rule, and Brian's Brain. It's fun to see it all wrapped in a bow ending this long project. We'll be back on March 31st with a whole new project.
Bart's full tutorial shownotes are at bartbusschots.ie/...
This week Bart and I celebrate 50 episodes of Programming By Stealth. As Bart points out, we've been at this for two years now. I'm so happy he's stuck with me on this and he says he's got literally years of material yet to go. To commemorate this occasion, Bart got the crazy idea to build a web app live on video. We used a YouTube Live Hangout on Air while he shared his screen. He started with a blank canvas and when he was done we had a working web app.
The video is probably a better experience over at podfeet.com but the audio is supplied for those who prefer it. We did try to narrate what was going on to help with the audio.
As promised last week, Bart Busschots brings us the second half of Programming By Stealth 49. We start by going through a lot of revision on JavaScript objects. It's really great to have all of this all in one place, and I got to ask a few questions that have been bugging me for a long time. I understood every bit of this and really enjoyed it, but I'm not going to lie, his little 6-part test after the revision baffled me a bit. But after we slog through that part, Bart gets us back on track improving our Cellular Automata. I never realized that we didn't actually define whether our cells are dead or alive!
In this week's episode of Programming By Stealth, Bart had intended to work on improving our Cellular Automata, but we ended up spending a lot more time on reviewing the challenges from last week that we stopped before getting to the new stuff. The good news is that we're going to do the Cellular Automata improvements in only one week (it will be PBS 49B), and we have no homework for the week! As always, Bart's excellent tutorial shownotes are available at bartbusschots.ie/....
Bart decided to take a closer look at the JavaScript keywords 'this' and 'static' and boy am I glad he did. He said it was the hardest lesson he's put together so far. It's a convoluted topic but he gives great explanations as always. You can find his tutorial at bartbusschots.ie/...
In this installment of Programming By Stealth, Bart teaches us about inheritance (relationships between classes) and polymorphism. Now he said polymorphism is a concept that throws most first-level college students, but in an odd twist, I didn't find it confusing at all! Plus, he lets us play with cows, ducks and turkeys in his example so it's loads of fun.
We also have a great new study tool created by Dorothy, aka MacLurker. She created an index of terms so you can jump right to the blog post where Bart talked about the term. I've been using it and it's grand! You might want to bookmark podfeet.com/blog/pbs-index.
As always, Bart's most excellent written tutorial is available at bartbusschots.ie/....
In this installment of Programming By Stealth, Bart adds one more thing to the list of changes to arrays, and that's the spread operator. Then we'll learn how to get rid of the "const self = this" kludge for callbacks using the arrow functions. After that, we learn the basics of classes, a concept introduced in ES6 which brings JavaScript into the world of other C-style languages.
Bart's excellent written tutorial for this installment is available here: bartbusschots.ie/...
Bart at the end asks a question - would you be interested in learning how to build command line apps using JavaScript? So far we've only be working on web apps, but command line apps will allow us to manipulate things in the file system, the network and even to the Internet itself without using a web browser. Let us know via email to me at allison@podfeet.com, or write up your thoughts in our Facebook group at podfeet.com/facebook or our Google Plus group at podfeet.com/googeplus or you can even tweet us at @podfeet and @bbusschots.
In this week's Programming By Stealth, Bart starts by actually giving me credit for leading him to rethink his strategy on the use of const and let. He was nudged along in the strategy by the most awesome Jill.
Then Bart goes on to reveal even more of the joy that is JavaScript ES6. He explains ES6 Arrays, how to loop through Arrays, and in a change that brings a tear to my eye, the simpler way you can now loop over Strings and how concatenation is a thing of the past when building strings. This is truly a joyful show!
As always, Bart's detailed tutorial is available at bartbusschots.ie/...
In this installment of Programming By Stealth, Bart Busschots teaches us new ways to deal with arguments and objects in JavaScript ES6. We learn how to set default argument values for functions in a way that is self-documenting. He explains how variadic (aka Rest) arguments allow you to shove all of the arguments of a function into an array. Then he walks us through how to use for ... in loops to loop over objects. He reminds us of the difference between instance and static properties and explains how for ... in loops work with both kinds of properties. I really enjoyed this episode and followed almost all of it on the first time through!
In this installment of Programming By Stealth, Bart spends most of the time talking through his solution to the previous challenge, where we added start and stop buttons to our Game of Life. In his solution he actually modifies the prototype to accommodate the ability to add these buttons. He explains his process and his decisions along the way. I'm not going to lie, this one confused me quite a bit in the middle but we both hope it's because we've been away from the hard-core JavaScript for quite a while.
Once we have that under our belts, he starts explaining some of the cool, new features in JavaScript ES6 where we abandon var and replace it with let and const. He explains the value of these new terms (and the problems they solve!)
Bart's full tutorial is available as always at bartbusschots.ie/...
CCATP #507 for October 29, 2017, and I'm your host, Allison Sheridan. It is also a Programming By Stealth, installment 42 of X with Bart Busschots. It's finally time to tie all the bits and pieces we've learned together and create our first web app. Armed with our HTML, CSS, jQuery and JavaScript knowledge, and our Cellular Automata Prototype, Bart walks us through how to bring the Game of Life...to Life! It's a lot of fun and I understood a great deal of it (I'm not gonna lie, it wasn't 100% this time.)
As always Bart's amazing tutorial for this episode is available at: bartbusschots.ie/
In this episode of Programming By Stealth, Bart ties up the last of the loose ends related to web forms. He teaches us about form events, which are critical to making our web forms not only accessible to screen readers but to allow our users to tab around to the different fields and interact with them without using a mouse. We learn about the keypress event and learn what it means for 31 to be the space key.
In a shocking turn of events, I actually followed all of Programming By Stealth this week! Bart walked us through his solution to last week's HTML5 Forms Validation homework, and in so doing highlighted some especially clever things he did. I was pretty pleased with my own version of the homework, and in fact Bart gave me a gold star for one thing I did. Bart also explains how he used CSS to make his form even more readable.
In the second half of the episode he shows how to use jQuery to improve the forms even more. He demonstrates how certain requirements cannot be met with the built-in forms validation and how we can use jQuery instead. I loved this episode because it tied in our knowledg of jQuery back to HTML forms.
Bart's most excellent written tutorial can be found at PBS 40 of x – HTML5 Custom Validations with jQuery on bartb.ie.
This week Bart Busschots joins us to talk about HTML Form Validation. We'll get back to our Cellular Automata next week. Bart has also decided that we're going to get our feet a little bit yet by using GitHub where we'll be getting the challenges and solutions from now on. You can see Bart's awesome tutorial at bartbusschots.ie/...
We finally reached 500 episodes of Chit Chat Across the Pond (episode 499 will be next week) so who better to have on the show than Bart Busschots who started it all? In our first Programming By Stealth after our summer vacation, Bart decided to do a retrospective on what we've learned to date from HTML to CSS to JavaScript. I thought it was a great episode because it refreshed my memory on so much that we've done. He even put together a set of quiz questions for each section and shockinglyI didn't do too badly at them! It was a lot of fun and I hope you enjoy this refresher episode as much as I did. Of course Bart's fabulous written tutorial is available at bartbusschots.ie/...
I've been asking Bart a lot of questions in the back channel as I struggle to understand the documentation he has provided in our latest few sessions of homework assignments. He had an epiphany last week that he had never explained the documentation methods itself, which was certainly adding to my confusion.
He decided to take a step back and explain step by step using video. He created a video screencast of the entire process of creating documentation using JSDoc. Then during the audio recording you'll hear in the podcast, he walked through it again while I asked him (lots of) questions. Hopefully it will be as eye opening to you as it was to me. He also demonstrates his favorite tools for the process.
You can find Bart's blog post with the embedded video screencast at bartbusschots.ie/...
Chit Chat Across the Pond this week is another episode of Programming By Stealth with Bart Busschots. I'm very proud of the fact that I completed my homework, writing a program from scratch that passed all of the tests written by Bart. It took me 12 hours, and nearly 4 hours of Dorothy's time helping me do it, but I got 'er done. In this installment, 36 of x, we learn some more HTML, specifically about all the cool things the input tag can do, like creating invisible forms which is just weird but also very cool. The challenge this week is a flip on last week. This week Bart has written the next bit of code for us and we have to create the tests. It's as challenging as all the rest but it's just as fun. And of course you can find Bart's fabulous tutorial show notes at bartbusschots.ie/...
In this installment, Bart walks us through a little bit of how he wrote his Test Driven Development with QUnit for the Bartificer Link Toolkit. Bart even explains how it helped him find a couple of pretty major bugs in his own code, proving how important this is. Then we make a start on text input in HTML forms, and we move on to formatted sub-stets of tea like numbers, email addresses and so on.
Finally, we make a start on what will be an on-going project. The idea is to combine our understanding of HTML, CSS, JavaScript, jQuery, and QUnit to implement a zero-player with a really cool computer science back-story.
In this installment of Bart’s Programming By Stealth series, we review our test code using QUnit, and then learn how to use QUnit to test our code within a real browser page. We do that using the API we built together, the Bartificer Link Toolkit that identifies external links on a web page, makes them open in new tabs, adds the tag rel=noopener, and adds a cute icon to identify them as external links. As always Bart’s terrific written tutorials and downloadable examples are available at pbs.bartificer.net/...
In this installment of Programming By Stealth, Bart FINALLY lets us start learning Test Driven development, or TDD. He shows us how to use a free and open source tool called QUnit, made by the fine developers of jQuery, to analyze our test code. It’s something I’ve been itching to learn more about, ever since listener Jill tipped us off to the concept. It’s a really fun episode where everything kind of comes together. Hope you enjoy it as much as I did. As always, Bart’s excellent written tutorial for the episode can be found at pbs.bartificer.net/...
This week Bart and I put the finishing touches on our Date and Time prototypes, then we use those very JavaScript prototypes with HTML forms, we learn bout JavaScript error handling (including throwing and catching errors) and the we start manipulating HTML Selects with jQuery. If that sounds as fun to you as it was to me, check out Bart’s full detailed show notes at pbs.bartificer.net/...
Bart and I may have broken a record on Chit Chat Across the Pond this week. We went through so much material in Programming By Stealth that this show runs 100 minutes! The funny thing is that I wasn’t ever bored, it was all really interesting. We started by going over last time’s JavaScript challenge where I made some mistakes but node.js saved me so I didn’t realize I’d entirely missed the point. I’m still getting the hang of that object thing. The we learned one final new concept related to JavaScript prototypes: static functions. The we finished that we went over to the html side and learned how to make forms, checkboxes and radio buttons. Not nearly as mentally challenging as JavaScript to be sure, especially since you can see the changes right on screen when you mess with them. Speaking of messing with them, Bart teaches us how to use jQuery to find out what our buttons and checkboxes say and to change them. He does this all with particular attention to using ARIA to ensure our html is accessible.
As always you can find his excellent tutorial to follow along at pbs.bartificer.net/...
Bart continues his current dual path of teaching. We learn how to compare JavaScript objects (spoiler, you can't use == or === to do it). After that he teaches us how using WAI-ARIA as we develop our code will make it accessible to screen readers and other assistive devices. We don't do any real coding in this section; instead he explains the foundation for what we'll be doing in the future.
I don’t want to jinx anything here, but I feel like I’m finally starting to “get” this JavaScript programming thing. In this episode of Programming By Stealth, Bart starts by talking about how we solved the challenges from last week, getting rid of “bad smells” by learning how to reuse our code. Then Bart teaches us about another bad smell, where inadvertently point two variables point the same object and he teaches us about the clone function to eradicate that problem. With that bite-sized JavaScript lesson behind us, he takes us forward into learning about Glyph Icons, a way of having scalable icons on our web pages instead of pixel-based icons. He introduces us to Font Awesome tool to get free access to (awesome) scalable glyph icons. The full tutorial is available at bartbusschots.ie/….
In this week’s installment of Programming By Stealth, Bart teaches us about how to change the look of HTML buttons using their CSS attributes. It’s great fun, but I have to confess we don’t actually get to the new stuff till over an hour into the show! We had so much fun going through the homework from last time that we lost track of time. I was so excited because I’d worked really hard on my homework this time and was able to actually conquer the first two parts (with some help from my friends) but I did struggle a bit with the third piece where I had to assemble them together. Anyway, we decided it’s ok if you skip ahead to the CSS parts if you like; it starts at an hour and six minutes in.
As always the full written tutorial with examples is at bartbusschots.ie/…
On this week’s continuing series Programming By Stealth, Bart introduces us to HTML forms in order to take user input. It’s a pretty basic installment so not as head bendy as they have been lately. He also gives us some more repetitive homework to get more practice creating and using prototypes and accessor methods. The full written tutorial can be found at bartbusschots.ie/….
Bart Busschots is back with another installment of Programming By Stealth. In this week’s episode we wake Allison up from her long winter nap away from programming and continue our work on our JavaScript clock. The goal is to create a better API for our clock so that we can publish it and have it be used by others. My personal goal is to have a secure clock I can display on https://podfeet.com/live so that you know when it’s coming up on 5pm at my house and hence time for the NosillaCast Live. In order to achieve this goal, we need to learn how to add data attributes within html, and then change those attributes using jQuery. Dust off your memories of prototypes and screw your propeller beanie on tight for this one!
Link to the full tutorial is available at bartbusschots.ie/…
Bart gave me another two weeks to get my homework done on Programming By Stealth and brings us a case study of how to create a JavaScript API on Github. He uses a real life example of a small, open source library he released over the weekend called barfificer.linkTookit.js. This library includes many of the bits and pieces we’ve been working on in Programming By Stealth, how to add a rel of no opener on all links with a target of _blank (the ones that open in a new tab) and adding a little icon in the url to politely tell the reader that you’ll be navigating away from the page you’re on. It’s a great lesson in the structure of how Github works and even more importantly how it automatically creates beautiful documentation from Markdown comments in the code. Tutorial shownotes are available at bartbusschots.ie/...
In this week’s installment of Programming By Stealth, Bart teaches us how to create a JavaScript API up to and including an easy way to create professional documentation in order to publish our work as a JavaScript library. In order to get there we learn how to write reusable and sharable code, how “closures” help you keep your variables out of the global scope so they don’t mess up other people’s code, we learn one Ternary Operator), and my favorite, self-executing anonymous functions.
Apologies for getting the episode number wrong in the audio – I said it was #460 when it’s actually #461.
You can find Bart’s tutorial we follow in this episode at bartbusschots.ie/….
In this installment of Programming By Stealth, we’re working towards our first truly practical assignment in the series – a function that finds all links on a page, and if, and only if, they lead to an external page, alters them to open in a new tab, and appends an icon indicating that fact. Bart’s amazing full on tutorial is over at bartbusschots.ie/…. I also mention a fun little jQuery Easter egg, which you can find at citymapper.com. Just follow the link and open the console on your favorite browser and you’ll find a text based adventure game!
Bart Busschots joins us again for his continuing series called Programming By Stealth. In this episode Bart explains how to embed JavaScript into a webpage, how to control when JavaScript executes and then teaches us about the browser event model. Using this model he teaches us how we can change things on a web page when the user clicks or after a defined length of time, or at time intervals. It’s our first time outside of the sandbox so it’s great fun to manipulate web pages and have them do our bidding! Bart’s full tutorial is at: bartbusschots.ie/… and it includes some downloadable files that are very useful for following along.
In this episode of Programming By Stealth, Bart ties up the last of the loose ends related to web forms. He teaches us about form events, which are critical to making our web forms not only accessible to screen readers but to allow our users to tab around to the different fields and interact with them without using a mouse. We learn about the keypress event and learn what it means for 31 to be the space key.
Bart’s excellent tutorial is at over at bartbusschots.ie/…
In this installment of Programming By Stealth with Bart Busschots, we finally break out of the sandbox and learn how to use the console in a web browser to start taking control of web browsers. Bart's full tutorial is available at bartbusschots.ie/….
In episode #449, Bart Busschots walked us through how he'd solve the first half of the JavaScript challenges from PBS 19. This week we finish the second half of the 5th problem about Complex Numbers. Like the last episode, we're giving you the audio in the podcast, but if you'd like to watch the video of Bart building the solutions, you can see that over on podfeet.com.
Bart Busschots got the crazy idea that we should do this episode as a video so that he could solve the JavaScript challenges from PBS 19 real time and talk through it as he solved them. I figured it would be mean to drop a giant video into your feed, so this is actually just the audio which is cool too, but you can go watch the video on podfeet.com.
In this episode of Programming By Stealth, Bart Busschots takes us through the final stages of learning JavaScript within the playground. Now that we know about objects, we need to re-visit the arguments object present in every JavaScript function. We need to take a detailed look at the typeof operator, and we need to look at some built-in objects and functions JavaScript provides. We also need to look at how JavaScript handles regular expressions, and finally, we need to introduce the concept of exception handling. Bart's full written tutorial is available at bartbusschots.ie/....
In this continuing series with Bart Busschots, we get a more detailed look at objects, and then we look at some standard functions and objects that are built into JavaScript. We also take a proper look at two operators we've seen before, typeof and instanceof. Bart's full written tutorial is available at bartbusschots.ie/....
In this installment of Programming By Stealth, Bart Busschots takes our understanding of functions to the next level. The techniques we encounter today would be considered advanced techniques in most other languages, and you could spend years developing in Java and never encounter an anonymous function. However, because of how JavaScript is integrated into HTML documents, these techniques are considered fundamental in JavaScript, and anonymous functions are a dime a dozen! Before we delve into anonymous functions, we’ll start by taking a deeper look at how JavaScript deals with function arguments.
Bart's full tutorial is available at bartbusschots.ie/....
In this week's episode of Chit Chat Across the Pond, Bart Busschots is back with Programming By Stealth episode 15 of x where he's going to teach us about JavaScript functions. he'll twist our brains a bit with recursive functions but it's a fun ride. And there's even a challenge at the end!
And as always, here's a link to Bart's terrific tutorial for the episode: bartbusschots.ie/...
We're back to Programming By Stealth with Bart Busschots where he explains how to create Arrays in Javascript and how to use "while" and "for" to create loops to access the information in Arrays. It's a little bit of a propeller beanie episode but we powered through till I got it!
And as always, here's a link to Bart's terrific tutorial for the episode: bartbusschots.ie/....
In this week's episode of the continuing series with Bart Busschots, he introduces the concept of conditionals. We'll learn whether boogers is true or false, how Javascript handles text strings and numbers in comparisons (what's bigger or smaller), how equality is really three different things, and we'll learn about logical operators like AND, OR and NOT to be used in conditional statements. Bart has updated the Javascript Playground he created so be sure to grab the new version.
The entire tutorial is available here: bartbusschots.ie/....
In this installment of Programming By Stealth, Bart Busschots dips our baby toe into Javascript. We learn the very basic building blocs, including how to make statements, how to make comments, three rules for variables, the difference between strings and numbers and what you can do with them, operators and concatenation. With the exception of the modulus section, I understood everything he said! Learn why this episode ends with the line, "Find out next week if boogers is true or false!" Find Bart's detailed tutorial at bartbusschots.ie/... including a link to his JavaScript Playground.
Finally, after many months of making us wait, Bart has decided it's time to look at tables on web pages. We’ll start by describing the HTML markup for tables, and then look at how to style them with CSS. Full tutorial at bartbusschots.ie/...
Check out the latest installment of Programming By Stealth from Bart Busschots. He takes me through four new CSS methods to style lists, he teaches me more CSS selectors, and then we get to play with pseudo-classes. It's great fun and I think I actually understood most of it! As always with the Programming By Stealth series, it's highly recommended that you follow along with Bart's amazing tutorial here:
https://www.bartbusschots.ie/s/2016/03/04/programming-by-stealth-10-of-x-yet-more-css/
This week Bart introduces a visual tool he created just for us (well, for me) to help us really understand how the box model works in CSS. You can see his tool here: bartbusschots.ie/... and follow along with his detailed tutorial on More CSS Positioning here: bartbusschots.ie/....
Buckle up everyone - in this Installment of Programming By Stealth, Bart will dig in deep on explaining how to position the blocks we've learned about before onto our web page using CSS. It's a tough hill to climb but Bart stays patient with me till I THINK I've got it!
You can find Bart's amazing tutorial at bartbusschots.ie/....
Bart Busschots joins us again for part 7 of his series Programming by Stealth. In this instalment we’ll build on our basic understanding of CSS from previous instalment. We’ll start with some new CSS selectors, in the process, introduce two new HTML tag attributes, then we’ll move on to the CSS box model. Each HTML tag is represented in the page as a box, and all those boxes can be manipulated with CSS.
Find Bart's detailed tutorial at bartbusschots.ie/....
In the 6th installment of Bart Busschots' Programming by Stealth series, he introduces the concept of CSS to allow us to format our html pages. He gives us an overview of terminology, explains the different ways to add CSS to an HTML document, explains the basic syntax, and finally gives us some examples of text attribute changes. You can find his detailed shownotes at bartbusschots.ie/....
Also note that he's now created a short url for us to be able to see all of the Programming By Stealth tutorials all in one place (along with an adorable logo) at http://bartb.ie/pbs.
In this week's episode of Chit Chat Across the Pond we have Bart Busschots with another installment of Programming by Stealth. He covers the syntax for images and links in HTML and the attributes you can apply and more importantly why you should apply them. He promises that with the first 5 episodes under our belts we'll be ready to move on to understanding CSS, or Cascading Style Sheets. You can read along with his detailed tutorial and download the example files at \bartbusschots.ie/s/2015/12/27/programming-by-stealth-5-of-x-images-links/.
In the previous installment Bart introduced us to the concept of block-level tags, and in-line tags. Block level tags define blocks of text like headers, paragraphs and lists, and starting a new block-level tag generally starts a new line in the page. Inline tags on the other hand effect a part of a block, and opening an inline tag generally doesn’t start a new line. In the previous installment we looked at some of the most important block-level tags, in this installment we’ll look at some of the most common in-line tags.
In the previous instalment we introduced HTML, learned about HTML tags in the abstract, and looked at a basic template for all HTML pages. Over the next few instalments we’ll be working our way through the common HTML tags.
Bart Busschots is back with episode 2 of his Programming By Stealth series. He’ll take us on our first baby step towards programming by explaining how the Hyper-Text Markup Language works, better known to us all as HTML. HTML is not a true programming language, it is instead a simpler beast known as a markup language – it adds context to text.
Bart’s companion tutorial can be found on his website at bartbusschots.ie/s/2015/10/23/programming-by-stealth-2-of-x-basic-html.
In this inaugural episode of Programming By Stealth, computer scientist and linux system admin Bart Busschots explains what his approach is going to be on teaching us to program. He plans to emphasize methods and concepts while teaching us specific languages along the way. As he says, "The tool you happen to use most today is unlikely to be the one you use most a decade from now." Bart has over 20 years of programming in X86 Assembler, BASIC, C, C++, Java, JavaScript, Perl, PHP, BASH, Lisp, Maple, Matlab, and more. We don't know how long this series will go, hence the "of X" in the title.
The written tutorial that accompanies Bart’s Programming By Stealth – 1 of X can be found at bartbusschots.ie/s/2015/10/09/programming-by-stealth-1-of-x-introduction/.