Arts and Culture
More from Google
Add by RSS Feed
Get the Android app
Get the iOS app
Programming By Stealth
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.
Jan 31, 2021
PBS 111 of X – Stashing Changes
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
1 hr 1 min
Jan 16, 2021
PBS 110 of X – Merge Conflicts
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/...](https://pbs.bartificer.net/pbs110) And if you learn a lot from Bart, please consider becoming a patron of his by going to [www.patreon.com/...](https://www.patreon.com/ltpod/posts)
Dec 28, 2020
PBS 109 of X — SemVar & Structured Commits
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/...
1 hr 3 min
Dec 18, 2020
PBS 108 of X — Merging & Tagging
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/...
1 hr 9 min
Nov 29, 2020
PBS 107 of X – Branching Basics
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.
1 hr 13 min
Nov 20, 2020
PBS 106 of X — Time Travel with Git
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/...
Nov 7, 2020
PBS 105 of X – Seeing the Past with Git
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.
1 hr 2 min
Oct 24, 2020
PBS 104 of X – Tracking Changes in Git
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/... * firstname.lastname@example.org * Support Bart on Patreon * Join Our Slack
Oct 11, 2020
PBS 103 of X — Getting Started With Git
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 * email@example.com * Tesla Affiliate Link * podfeet.com/patreon * podfeet.com/slack * podfeet.com/facebook * podfeet.com/paypal
Sep 27, 2020
PBS 102 of X – Introducing 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.
1 hr 13 min
Sep 12, 2020
PBS 101 of X - Introducing Version Control
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.
Aug 30, 2020
PBS 100 of X — Time Sharing Challenge Solution
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
1 hr 38 min
Aug 7, 2020
CCATP #649 – Dr. Helma van der Linden on Creating a Book with Open Source Software
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 lin…
1 hr 8 min
Jul 12, 2020
PBS - Can We Interest You in a Cup of Taming the Terminal?
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.
Jun 28, 2020
PBS 99 of X – Building with Classes Part 2: Is-A
1 hr 14 min
Jun 13, 2020
PBS 98 of X — Building with Classes Part 1 — Has-A
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/...](https://pbs.bartificer.net/pbs98)h
1 hr 26 min
May 31, 2020
PBS 97 of X — Class Data Attributes & Functions
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 showno…
1 hr 19 min
May 16, 2020
PBS 96 of X — World Clock Challenge Solution
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.
1 hr 16 min
May 2, 2020
1 hr 9 min
Apr 18, 2020
1 hr 32 min
Apr 5, 2020
Mar 20, 2020
PBS 92 of X — Currency Grid Solution
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](https://pbs.bartificer.net/p…
1 hr 17 min
Mar 7, 2020
Feb 22, 2020
1 hr 35 min
Feb 8, 2020
Feb 8, 2020
PBS Tidbit 1 of Y — Display Values are not Data!
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/...
Jan 26, 2020
PBS 89 of X — Currency Converter Challenge
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.bartifice…
1 hr 19 min
Dec 14, 2019
PBS 88 of X — DOM & jQuery Objects Redux
1 hr 51 min
Nov 30, 2019
1 hr 58 min
Nov 3, 2019
1 hr 22 min
Oct 20, 2019
1 hr 23 min
Oct 4, 2019
PBS 83 of X Bootstrap Cards
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 * firstname.lastname@example.org * podfeet.com/patreon * podfeet.com/slack * podfeet.com/facebook * podfeet.com/amazon
1 hr 10 min
Sep 20, 2019
PBS 82 of X – Async & Await
1 hr 33 min
Jul 12, 2019
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/... * email@example.com * podfeet.com/patreon * podfeet.com/slack * podfeet.com/facebook * podfeet.com/amazon
1 hr 1 min
Jun 25, 2019
PBS Supplemental — Dorothy Rendon on the PBS Index
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. * firstname.lastname@example.org * podfeet.com/patreon * podfeet.com/slack * podfeet.com/facebook * podfeet.com/amazon
Jun 14, 2019
1 hr 46 min
May 31, 2019
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/...
1 hr 25 min
May 17, 2019
PBS 78 — is.js & Bootstrap Popovers
1 hr 39 min
May 5, 2019
PBS 77 of X — More Callbacks & More AJAX
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.
1 hr 30 min
Apr 22, 2019
PBS 76 of X - AJAX with jQuery
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.
1 hr 39 min
Apr 7, 2019
PBS 75 of X - AJAX Intro
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.
1 hr 17 min
Mar 24, 2019
PBS 74 of X - More Mustaches
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/...](https://www.bartbusschots.ie/s/2019/03/24/pbs-74-of-x-more-mustaches/)
Mar 10, 2019
PBS 73 of X - Mustache Templates
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!
1 hr 29 min
Feb 23, 2019
PBS 72 - HTML5 Templates
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.
1 hr 7 min
Feb 10, 2019
PBS 71 of X - Bootstrap Spinners
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.
1 hr 42 min
Jan 28, 2019
PBS 70 - Bootstrap Modals & Toasts
1 hr 31 min
Jan 13, 2019
PBS 69 of X — Bootstrap Navbars
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/...](https://www.bartbusschots.ie/s/2019/01/13/pbs-69-of-x-bootstrap-navbars/)
1 hr 5 min
Dec 15, 2018
PBS 68 of X - Bootstrap Navs
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/...](https://www.bartbusschots.ie/s/2018/12/15/pbs-68-of-x-bootstrap-navs/)
1 hr 16 min
Dec 2, 2018
PBS 67 of X - Bootstrap Dropdown Menus
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.
Nov 3, 2018
PBS 66 of X - Bootstrap Form Validation
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.)
1 hr 34 min
Oct 21, 2018
PBS 65 of X — Bootstrap Input Groups
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.
Oct 5, 2018
PBS 64 - Bootstrap Form Layouts
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!
Sep 23, 2018
PBS 63 of X — Bootstrap Buttons
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!
1 hr 8 min
Sep 15, 2018
PBS 62 of X — A Basic Bootstrap Form
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/...
1 hr 11 min
Aug 30, 2018
PBS 61 of X — Bootstrap Jumbotrons & Badges
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.
Aug 13, 2018
PBS 60 of X - Bootstrap & jQuery
1 hr 5 min
Jul 28, 2018
PBS 59 of X — More Bootstrap Breakpoints
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/...
Jul 15, 2018
PBS 58 of X - Bootstrap Breakpoints
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/...
Jun 30, 2018
PBS 57 of X - the Bootstrap Grid
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
1 hr 20 min
Jun 16, 2018
PBS 56 - More Bootstrap Content
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/....
Jun 2, 2018
PBS 55 - Bootstrap Content
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/...
May 19, 2018
PBS 54 of x - More Bootstrap Utilities
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.
1 hr 15 min
May 5, 2018
PBS 53 of X — Bootstrap Utilities
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/...
Mar 31, 2018
PBS 52 - Introducing Bootstrap 4
1 hr 8 min
Mar 3, 2018
PBS 51 - Cellular Automata Wrap-up
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/...
1 hr 12 min
Feb 18, 2018
PBS 50 - Building a Web App on Video
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.
2 hr 3 min
Feb 10, 2018
PBS 49B of X - Object Revision & Improving Our Cellular Automata
1 hr 48 min
Feb 3, 2018
PBS 49A of X - Challenges from PBS 48
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/....
Jan 20, 2018
PBS 48 of x – A Closer Look at ‘this’ and ‘static’
1 hr 32 min
Jan 6, 2018
PBS 47 - ES6 Polymorphism
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/....
1 hr 22 min
Dec 21, 2017
PBS 46 - ES6 Spread Operator, Arrow Functions & Classes
1 hr 5 min
Dec 11, 2017
PBS 45 – ES6 Arrays & Strings
Nov 26, 2017
PBS 44 - ES6 Arguments & Objects
Nov 12, 2017
1 hr 37 min
Oct 29, 2017
PBS 42 of x – Playing the Game of Life
1 hr 41 min
Oct 13, 2017
PBS 41 of x - Form Events
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.
1 hr 31 min
Sep 30, 2017
PBS 40 of x - HTML5 Custom Validations with jQuery
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.
1 hr 52 min
Sep 15, 2017
PBS 39 of x - HTML5 Form Validation
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/...
1 hr 15 min
Sep 2, 2017
PBS 38 of x - Taking Stock
Jul 9, 2017
PBS 37 of x - JSDoc Demo
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/...
Jun 25, 2017
PBS 36 of x – More HTML Text Input | More Cellular Automata
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/...
May 19, 2017
PBS 35 of x - HTML Text Input | Introducing ‘Life’
Feb 18, 2017
PBS 30 of x - Comparing JS Objects | Introducing WAI-ARIA
Feb 4, 2017
PBS 29 – JS Prototype Revision | Glyph Icons
Jan 21, 2017
PBS 28 – CSS Attribute Selectors & HTML Buttons
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/…
Jan 2, 2017
PBS 27 – Introducing HTML Forms
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/….
Dec 11, 2016
PBS 26 – HTML Data Attributes with jQuery
Nov 22, 2016
Oct 28, 2016
Oct 14, 2016
PBS 23 – Creating Elements with jQuery
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!
Oct 1, 2016
PBS 22 – jQuery Events
Sep 16, 2016
PBS 21 of X – jQuery Basics
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/…
Sep 2, 2016
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/….
Aug 17, 2016
Aug 6, 2016
Jul 8, 2016
Jun 25, 2016
Jun 11, 2016
May 27, 2016
May 13, 2016
Apr 12, 2016
Apr 1, 2016
Mar 18, 2016
PBS 11 of x - Tables
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/...
Mar 4, 2016
PBS 10 of x - Yet More CSS
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/
Feb 19, 2016
PBS 9 of x - More CSS Positioning
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/....
Feb 6, 2016
PBS 8 of x - CSS Positioning
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/....
Jan 22, 2016
PBS 7 of x -More CSS
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/....
Jan 9, 2016
PBS 6 of x - Introducing CSS
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.
Dec 28, 2015
PBS 5 of x - HTML Images & Links
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/.
Nov 21, 2015
PBS 4 of x - HTML In-line Elements
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.
Nov 8, 2015
PBS 3 of X - HTML Block Elements
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.
Oct 24, 2015
PBS 2 of X - Introducing HTML
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.
Mar 18, 2015
PBS 1 of X - Introduction