Programming By Stealth

Latest Episodes:

PBS 104 of X – Tracking Changes in Git Oct 24, 2020

Show notes

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

PBS 103 of X — Getting Started With Git Oct 11, 2020

Show notes

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

PBS 102 of X – Introducing Git Sep 27, 2020

Show notes

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.

PBS 101 of X - Introducing Version Control Sep 12, 2020

Show notes

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.

PBS 100 of X — Time Sharing Challenge Solution Aug 30, 2020

Show notes

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

CCATP #649 – Dr. Helma van der Linden on Creating a Book with Open Source Software Aug 07, 2020

Show notes

This week our guest is Dr. Helma van der Linden from the Netherlands here to talk about how she created the Taming the Terminal book using all Open Source software.

On the NosillaCast I talked a lot about the book but I should probably give an explanation for the Chit Chat audience. Bart Busschots and I created the Taming the Terminal podcast and for this series on learning the macOS (and Linux) command line, Bart wrote a spectacular set of tutorial shownotes on his website at bartb.ie.

I had a dream for many years to make Taming the Terminal into a book as a surprise for Bart, but my few attempts to do it failed spectacularly. Around Easter, I mentioned my dream to Helma and she said, “I bet I could do that!”

I don’t expect anyone to learn from this discussion how to do what Helma did, but rather to learn what’s possible and how cool it was that Helma put these pieces together. Below are the rough shownotes we used for our discussion, included so that you would have the links to all of the tools she explained in the episode

Downloads of the book can be found at podfeet.com/tttbook and the GitHub project for Taming the Terminal can be found at github.com/bartificer/taming-the-terminal. You can communicate with Helma through our Slack community at podfeet.com/slack where her handle is @Helma.

PBS - Can We Interest You in a Cup of Taming the Terminal? Jul 12, 2020

Show notes

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.

PBS 99 of X – Building with Classes Part 2: Is-A Jun 28, 2020

Show notes

This week Bart Busschots brings us the penultimate JavaScript installment of Programming By Stealth as he brings us part 2 of building with classes. This wraps up our third look at Object Oriented programming in JavaScript. We learn about the concept of inheritance, and how it allows us to build classes that inherit attributes and functions from parent classes. This allows us to eliminate code duplication which Bart explains is called a "bad smell".

You can find Bart's tutorial shownotes at pbs.bartificer.net/pbs99.

PBS 98 of X — Building with Classes Part 1 — Has-A Jun 13, 2020

Show notes

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

PBS 97 of X — Class Data Attributes & Functions May 31, 2020

Show notes

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](https://pbs.bartificer.net/pbs97).

Our TOPPODCAST Picks

Follow Us

Stay Connected

Related Podcasts

Links

Stay Connected