Programming By Stealth is a collaborative series created by Bart Busschots and Allison Sheridan, as part of the Chit Chat Across the Pond podcast. If you would like to subscribe to this podcast without the “Lite” version of Chit Chat Across the Pond, use this Apple Podcasts Link or paste this link into your podcatcher of choice:
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/…
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.net.
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 SemVer. 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.
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/…
In this installment of Programming By Stealth, 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.
Follow along with Bart’s tutorial shownotes at pbs.bartificer.net/…
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/…
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
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.
Bart’s tutorial show notes are at pbs.bartificer.net/…
In this turning of the century episode of Programming By Stealth, 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 installments, 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 me. To say that Bart was surprised and delighted would be an understatement!
The actual episode was an opportunity for Bart and me to share our respective solutions to the challenge from PBS 96, which was to create a web app that would allow a podcaster to send a time of their choosing to another podcaster. He didn’t put a lot of restrictions around it, so our solutions are completely different.
I begged to go first because I told him that going after him is like being the comedian who had to go on after Robin Williams. He replied that he wanted to go first for the same reason! He explained that I took on a much harder task than he did. In his solution, he picks a time in his own timezone and then copies a URL from the site and sends it on to the other people and they see the time he chose in their own browser. He did add a few bells and whistles beyond that but it’s the basic idea.
My solution allows the user to enter two timezones of their choosing and then drag a slider to shift time to see how convenient it is for the other person, and then copy the time. I was quite pleased with my user interface, and Bart even borrowed one of my ideas to use a utility called Bootstrap Collapse to show and hide certain page elements. To be doing something that Bart wants to emulate warmed my little heart.
A fun fact about our solutions is that Bart worked on his for an entire 3 days, and I worked on mine for two months on and off. I’m still proud of what I accomplished!
You can read Bart’s and my tutorial shownotes for this episode by going to pbs.bartificer.net/… Thank you Bart for this amazing accomplishment.
Hi, Programming By Stealth listeners! I wanted to let you know that Bart and I are taking a bit of a break from Programming By Stealth, the need for which happens every summer but for some reason catches us both unawares each year. Bart works in education and the summertime is the only practical time to make huge changes to the computer systems underlying said education. As you might guess, this year presents even more “interesting” challenges.
However, Bart and I are not lying down on the job, and we have something to offer you while you await the next installment of Programming By Stealth.
Five years ago Bart and I started a series called Taming the Terminal which ran for 35 of n episodes. Like Programming By Stealth, he made the ending indeterminate. He did this because while he accomplished the teaching he set out to do, he knew that things would change in the macOS terminal and new advances would be the opportunity for new episodes.
After a year hiatus, he brought us episode 36 in late 2016 where he taught us about
screen which allowed you to SSH into servers and start processes that would continue even while disconnected. In mid-2017 he taught us about SSH agents to address a change in El Capitan that made you have to enter your passphrase to a server more often. This affected what we were taught in TTT30 about SSHing into our servers.
It turns out that Red Hat deprecated
screen recently and instead there’s a tool called
tmux that does everything
screen used to do and more.
This week Bart and I recorded installment 38 of n in which he taught us the basics of
tmux that replace
screen‘s functionality. And in two weeks we’re going to publish the second half of the
tmux story where he will teach us the other cool stuff it can do.
If you are an avid listener to Programming By Stealth, then I’m sure that Taming the Terminal will be a fun podcast for you. You can easily jump in right now to episode 38 or you can start at episode 0 and listen to all the back catalog.
As always you can find Taming the Terminal in your podcatcher of choice, and this week’s episode is also included in the full Chit Chat Across the Pond feed.
Or you can listen to Taming the Terminal installment 38 of n right here:
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/…
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.
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 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.
You can read the tutorial shownotes as you listen at pbs.bartificer.net/…
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.
You can see how Bart created this in his blog post at www.bartbusschots.ie/…
Bart’s tutorial for this episode are available at pbs.bartificer.net/…
Bart’s shownotes for this episode can be found at pbs.bartificer.net/pbs90.
This is not a normal episode of Programming By Stealth, it’s what Bart Busschots is calling a PBS Tidbit. Listener @lbutlr pointed out to Bart and me on Twitter that Bart’s math was wrong in his solution to the challenge he posted in PBS 89. The assignment was to produce currency exchange rates for a variety of currencies, based an amount for the base country. That is, 10,000 Japanese Yen is how many Euro, Canadian Dollars and New Zealand Dollars.
The problem was that if you chose large amounts (like 10,000 Yen), Bart’s math fell over in a heap, returning 100 for all countires or with South Korean Won, most countries returned 0.
Instead of being incensed or embarrassed at having made a mistake, Bart dug in, figured out what went wrong, and then wrote up his path to discovery and the tools he used to fix the mistake. He made it a teachable moment. He decided to call this PBS Tidbit 1 of Y because this probably won’t be the last time this happens.
After Bart finished, I talked about another thing @lbutlr told us and how I’m trying to implement it in my challenge solution. I’ll be writing that up once I get it figured out.
You can read Bart’s explanation at www.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 the 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.
This week’s installment then is a review of why he made certain decisions on how to solve the last Programming By Stealth challenge, which was to add the ability for the user of our currency exchange web app to enter a value to be converted to the different currencies.
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. This is very much a work in progress and we expect a few learning opportunities along the way!
With all that said, you can find the shownotes to this week’s installment at pbs.bartificer.net/…
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.
You can find Bart’s tutorial shownotes at pbs.bartificer.net/…
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’s tutorial shownotes can be found at pbs.bartificer.net/…
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 pbs.bartificer.net/…
Bart’s tutorial shownotes can be found at pbs.bartificer.net/…
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 pbs.bartificer.net/…
A quick note here – Dorothy, aka @maclurker in our Slack group has been applying all of her newly-acquired programming skills from PBS to her fabulous PBS Index. She’s now using Mustache templates, Bootstrap styling utilities, and even AJAX with JSON. The result is a beautiful thing to behold, giving us immediate results as you start to search and more. Bart has now made a permanent URL for the PBS Index, it’s bartb.ie/pbsindex.
Since Bart works for a University, summers are not a time of rest and relaxation for the system admin staff, they’re the only time upgrades and maintenance can get done because the students are gone. In the future, we think we’ll plan our summer hiatus for Programming By Stealth rather than it taking us by surprise each year.
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.bartificer.net/…
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 pbs.bartificer.net/…
In the very first Programming By Stealth supplemental episode, I interview 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.
We’ll first get a little background on Dorothy and then move on to learning how she used to produce the index, and how her advanced learning in Programming By Stealth allowed her to simplify the process and make it prettier, using JSON, Bootstrap and mustaches. I didn’t want to leave you without something in your Programming By Stealth feed while I’m on vacation and I think you’ll find it a lot of fun.
If you want to chat with Dorothy about the PBS Index, you can find her in the Podfeet slack at podfeet.com/slack under the handle @MacLurker.
You can find Bart’s detailed shownotes at pbs.bartificer.net/…
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 pbs.bartificer.net/…
As always, Bart’s awesome tutorial shownotes are available pbs.bartificer.net/…
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 are 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.
You can find the written tutorial for this episode at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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.
You can find Bart’s amazing shownotes for this episode at pbs.bartificer.net/…
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 pbs.bartificer.net/…
In this installment of Programming By Stealth, Bart Busschots teaches us about Mustache Templates. Mustache Templates are a library that allows 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!
Bart’s fabulous tutorial shownotes for this installment are available at pbs.bartificer.net/…
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.
Bart’s fabulous tutorial shownotes for this installment are available at pbs.bartificer.net/…
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.
And as always you can find Bart’s tutorial show notes at pbs.bartificer.net/…
And as always you can find Bart’s tutorial show notes at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…
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.
As always, Bart’s excellent tutorial shownotes are available at pbs.bartificer.net/…
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.)
Bart’s full written tutorial is available at pbs.bartificer.net/…
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.
Bart’s tutorial shownotes are available at pbs.bartificer.net/…
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 pbs.bartificer.net/…
If you appreciate the work Bart puts into Programming by Stealth, consider supporting him through Patreon by going to supporting him 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 pbs.bartificer.net/…
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.comw 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 pbs.bartificer.net/…
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.
You can get Bart’s full written tutorial at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…. If you appreciate the work Bart puts into Programming by Stealth, consider supporting him through Patreon or Paypal by going to lets-talk.ie.
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/… 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 pbs.bartificer.net/…
The link to Bart’s tutorial for this episode is at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 but the audio is supplied for those who prefer it. We did try to narrate what was going on to help with the audio.
You can find the download of Bart’s final file at pbs.bartificer.net/…
Bart’s tutorial for this lesson is at pbs.bartificer.net/… starting where he inserted the line, “Note: This is the point in the notes where the first podcast episode ends and the second begins.”
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…
Bart’s excellent written tutorial for this installment is available here: pbs.bartificer.net/…
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
let. He was nudged along in the strategy by the most awesome Jill.
As always, Bart’s detailed tutorial is available at pbs.bartificer.net/…
Detailed tutorial for the podcast is available at pbs.bartificer.net/…
var and replace it with
const. He explains the value of these new terms (and the problems they solve!)
Bart’s full tutorial is available as always at pbs.bartificer.net/…
As always Bart’s amazing tutorial for this episode is available at: pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 knowledge of jQuery back to HTML forms.
Bart’s most excellent written tutorial can be found at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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?
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…
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’ll move on to formatted sub-sets of text like numbers, email addresses and so on.
And as always Bart’s full written tutorial is available over at pbs.bartificer.net/…
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/…
As always you can find his excellent tutorial to follow along at pbs.bartificer.net/…
Bart’s tutorial and full show notes are at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…>.
Link to the full tutorial is available at pbs.bartificer.net/…
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 pbs.bartificer.net/…
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 pbs.bartificer.net/…. 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!