x

75% of people globally want unbiased news (Pew Research) but are concerned they're not getting that.

Get balanced coverage with Symby. See how stories are covered across diverse outlets and spot when one side covers a story the other skips.

PODCAST

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.

technology

All Episodes

66:14

PBS 118 of X — JavaScript Apps with GitHub Pages

Programming By Stealth ·

2021/06/12

In this installment of Programming By Stealth, Bart Busschots teaches us how to use a free service of GitHub called GitHub Pages. This service literally gives you free web hosting for the web apps we've learned to make in Programming By Stealth. Bart starts by explaining to us the difference between static and dynamic webpages, and web pages created by static site generators like Jekyll which generates GitHub Pages. It's trivially easy to create a GitHub Page from an open GitHub repo (literally

en

65:50

PBS 117 of X – Introducing GitHub

Programming By Stealth ·

2021/05/30

In this week's installment of Programming By Stealth, Bart teaches us how to use GitHub as a public repository for our code, or for anything we write for that matter. He reviews whey he chose Github, and then we dig right in. He does explain the benefits of using SSH to access Github instead of HTTPS, and if you haven't set up SSH keys before or you're rusty on the topic, he includes links to our sibling show, Taming the Terminal where you can learn how to do it. We create a new repo from scratch

en

56:23

PBS 116 0f X – Team Git

Programming By Stealth ·

2021/05/16

In previous installments of our Git miniseries within a series in Programming By Stealth, Bart taught us how to work in Git standalone on one computer, then how to work as one developer with multiple computers. In those installments he taught us the necessary commands and their importance in the Git scheme of things. In this installment he talks about how and where to work with a team in Git. We learn about the plethora of options from free to full enterprise-size Git-as-a-service, and why he'll be

en

55:22

PBS 115 of X – The Push & Pull of Git

Programming By Stealth ·

2021/05/02

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

en

63:21

PBS 114 – Tracking Git Branches

Programming By Stealth ·

2021/04/18

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

en

49:57

PBS 113 of X My First Git Remote

Programming By Stealth ·

2021/04/04

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

en

69:58

PBS 112 of X – Introducing Git Remotes

Programming By Stealth ·

2021/03/21

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"

en

61:17

PBS 111 of X – Stashing Changes

Programming By Stealth ·

2021/02/01

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

en

53:24

PBS 110 of X – Merge Conflicts

Programming By Stealth ·

2021/01/17

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

en

62:56

PBS 109 of X — SemVar & Structured Commits

Programming By Stealth ·

2020/12/29

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

en

68:53

PBS 108 of X — Merging & Tagging

Programming By Stealth ·

2020/12/18

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

en

73:19

PBS 107 of X – Branching Basics

Programming By Stealth ·

2020/11/29

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

en

50:43

PBS 106 of X — Time Travel with Git

Programming By Stealth ·

2020/11/20

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

en

61:44

PBS 105 of X – Seeing the Past with Git

Programming By Stealth ·

2020/11/08

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

en

PBS 104 of X – Tracking Changes in Git

Programming By Stealth ·

2020/10/25

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

en

59:35

PBS 103 of X — Getting Started With Git

Programming By Stealth ·

2020/10/11

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

en

72:59

PBS 102 of X – Introducing Git

Programming By Stealth ·

2020/09/27

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

en

58:41

PBS 101 of X - Introducing Version Control

Programming By Stealth ·

2020/09/13

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

en

98:15

PBS 100 of X — Time Sharing Challenge Solution

Programming By Stealth ·

2020/08/30

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

en

2:44

PBS - Can We Interest You in a Cup of Taming the...

Programming By Stealth ·

2020/07/12

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.

en

201 results

Similar Podcasts

Lead With AI

Tamara Nall

Linux in the Ham Shack

Black Sparrow Media

Data Engineering Podcast

Tobias Macey

Eye On A.I.

Craig S. Smith

Reflections

Livewire Labs