Samuel Taggart

The official "Architect of Adventure". I help teams create healthy, human-centered software development processes.

Coding Philosophy , OOP

Command Query Separation of Class Methods

In reading Micheal Feather’s book on Legacy Code, on page 147 it mentions the idea of command and query separation. A method should be a command or query, but not both. A command is a method that can modify the state of the object, but doesn’t return a

Book Reviews , Legacy Code

Working Effectively With Legacy Code

Several people have recommended this book to me over the years. I only recently got around to reading it. Software developers continue to recommend this 15-year-old book for good reason. It is quite useful because we all encounter legacy code and all of its techniques are still highly relevant. Thesis

Sam On Joel , Coding Philosophy

The Joel Test

The Joel Test is a classic. It’s been around for a while and is still increbibly relevant. It’s probably one of his most popular articles. I thought I would just go through each item and comment on how they apply to LabVIEW today. Looking at Joel’s list

Continuous Integration , How to

Trouble Shooting GitLabCI

I saw a post recently on LinkedIn by Jim Kring. He had some issues with a build hanging unexpectedly. They were running Jenkins under a system account and therefore it was really hard to see what was going on to be able to troubleshoot it. Jim then linked to a

Sam On Joel , Coding Philosophy

Back to Basics

So here is another article from Joel on Software. In this article, titled Back to the Basics, Joel talks about the importance of understanding how some lower-level things (like how strings are stored and memory management) work. It’s a bit of a rant. His conclusion is that you need

Book Reviews , Legacy Code

Legacy Code First Aid Kit

In general I hate digital only books. I much prefer physical books, but this one, like Dive into Design Patterns is worth making an exception for. Nicolas did a great job with this book. It covers 14 different tools to help get you started working with legacy code. If you

Kata , Legacy Code

Yahtzee Kata

The Yahtzee Kata is a common refactoring kata. You can see a version of it on Emily Bauche’s Github. As a refactoring kata, it requires some starting code. Emily’s page contains starting code for a lot of languages, but not LabVIEW. So I took it upon myself to

Book Reviews , Coding Philosophy

Peopleware

This book was recommended to me many years ago by a friend, but for some reason it took me a while to get around to reading it. I read it immediately after reading “Why Employees Are Always a Bad Idea” and a lot of the ideas seemed the same. Tom

Coding Philosophy , Book Reviews

Seven Transformational Training Assumptions

In the appendix of his book “Why Employees Are Always a Bad Idea”, Chuck Blakeman lays out his philosophy around training with 7 fundamental assumptions. Since we are all about training, coaching and mentoring here at SAS Workshops, I thought I would elaborate on his 7 assumptions and how I

Conferences , Announcements

GDevCon NA 2021 is on, in person!

GDevCon NA is now selling tickets! There are still some early bird tickets available. The date is October 20-21st in Boulder, CO. It’s going to be super exciting. We are also looking for more presenters and sponsors. You can get more info and buy tickets here: https://gdevconna.org/

Book Reviews

Why Employees Are Always a Bad Idea

Dilbert has been poking fun at corporate America for quite some time now. It wouldn’t be so funny if it did not contain some truth. Corporate America is broken and we all know it. “Why Employees are always a bad idea” explains why Dilbert resonates so much and what

Coding Philosophy

Code as Communication.

The code we write is a form of communication. We are telling the computer what to do, but we are also communicating with our colleagues. If we were only communicating with the computer, we could just simply write a bunch of 1s and 0s. That’s all the processor needs.

Coding Philosophy

Simplest Thing That Could Work

It seems like I have been giving the same piece of advice lately: Start with the simplest thing that could possibly work and only add complication as you need it. Sometimes our natural tendency is to plan for all eventualities. We get so caught up planning for what might happen,

Unit Testing , How to

A case for sets

Back in LabVIEW 2019, NI introduced both sets and maps. Maps became immediately popular. They should be. They are very useful constructs. However, sets seem to have gotten much less attention. In some ways, they aren’t as glamorous, but they do offer some advantages over arrays. To me, these

Coding Philosophy

Forget the word but

In improv, there is this idea called “yes and”. The idea is that the first person goes and starts telling a story. The second person (and everyone after them) picks up with “yes and” and then continues adding to the story. What you want to avoid doing is using the

SCC , How to , Software tools

A Better Way To Set Up LVCompare and LVMerge

EDIT: Since I originally wrote this post, I have come up with a much easier way. I am leaving this post up for historcial reasons, but do yourself a favor and just go here I have previously written about setting up LVCompare and LVMerge. I ran into a situation where

Coding Philosophy

The Freedom of Refactoring

Let’s talk about software design and refactoring in LabVIEW. When I first read Martin Fowler’s Refactoring book several years ago, it was very liberating. Prior to that, I had always had the idea that I had to get things right up front. It was kind of paralyzing. I

Sam On Joel , Coding Philosophy

Choosing a Language

I’ve decided to start a new series. I recently bought the book “Joel on Software” by Joel Spolsky. It is a collection of his blog posts. He still continues to produce more content today. Some of the articles in this book are a little dated but they seem to

How to , Continuous Integration , Legacy Code

Quick VI Analyzer

I haven’t talked a whole lot about VI Analyzer yet. It’s a static code analysis tool. If you come from text-based background, it is similar to a linter. It checks your code against a set of predefined rules and reports back any violations. You do need LabVIEW professional

Book Reviews

Fab and Richard's Book

As many of you know, last year Fab co-authored a book on LabVIEW with Richard Jennings. I was fortunate enough that she asked me to review a few chapters for her. As a way of saying thanks for that, she sent me a free copy. I’ve had it for

Book Reviews

Introduction to LabVIEW FPGA

I will start this review off by saying I am not much of an FPGA programmer. I took the NI class over a decade ago and I have an sbRIO dev kit sitting at home that I have played around with, but that is about it. On some previous cRIO

Continuous Integration , How to

GitLab CI and Git Bash

A while back GitLab CI deprecated the batch executor for Windows runners. That meant that you could no longer directly call batch scripts from a Gitlab Runner. They had switched over to Powershell. There were workarounds. You could still write a batch script and call it from PowerShell using cmd.

Coding Philosophy

Coding Camps and Climbing Gyms

I have been a programmer for over 15 years and a rock climber for over 20. During that time I have seen a lot of changes in both. In some ways, the changes are very similar. Rapid Growth Both programming and rock climbing have taken off over the past couple

Unit Testing , How to , Continuous Integration

Unit Tests for PPLs

So in my Unit Testing Workshop, I talk about taking tests written for libraries and retargetting them to the PPL once the library is built into PLLs. The last time I taught the workshop, someone asked me for an example. I didn’t have a good example to share, so

How to , Linux , Software tools , CRIO

CRIO Tips: Setting up VNC

This a follow on article to a couple previous articles: here and here. Its part of a series of tips that Neil Crossan provided me with, dealing with cRIOs and Linux RT targets. He saw a post of mine and sent me a bunch of tips and tricks. I thought