Programming By Stealth

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 co

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

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.

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

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 o

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 exercis

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

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 Prog