Lutherie - The Nashbronitacaster

How many of us are still chasing those childhood dreams? It struck me the other day that my professional and hobbyist pursuits today are a direct reflection of my interests in my teenage years. In some ways so little has changed. Still love to make music, diving deep into dissecting the sounds that tickle my eardrums. Still love to be creative. For decades now there's been a lot of programming and electric guitar. So here we have it, last post was about programming, and now, electric guitar. On brand!

The quest for a guitar that can do it all has been ongoing (as this recent post can attest), and the latest iteration has brought about a transformation of my first partscaster into what I'd describe as The Nashbronitacaster. A tele style, 3 pickup tone machine, with a combination of filtertron and single-coil style pickups.

The inspiration came from researching the guitars being used on many of today's most popular worship songs. As I contribute some sounds to the worship team on Sundays or Friday-nights, I like to try to emulate what many well-known artists have produced. Using a Kemper profiling amp to match amplifier tones and effects has been a key ingredient, but that's a topic for another time. When it comes to electric guitars, there were a few popular choices that stand out. One is the venerable Telecaster, which for many years has been my go-to instrument. Another increasingly popular choice are Gretsch-style guitars outfitted with some flavor of Filtertron pickups.

For example, the Gretsch Duo Jet appears to be used by the following well known guitarists (based on various rig rundown articles and observations from recorded worship performances): Jeffrey Kunde - Jesus Culture, Nigel Hendroff - Hillsong, David Liotta - Elevation, Cory Pierce, Julian Gamboa - Upperroom. In addition, the semi-hollow Gretsch guitars like the White Falcon or other solid-bodies like the Gretsch G6134 Penguin also appear in the stable of these same musicians. Seems these Filtertron pickups are a key ingredient with their relatively cleaner and brighter sound, compared to more prevalent humbuckers - which I've always found a bit too muddy/dark. For a brief introduction to these pickups, check out videos like What is the Filterton Sound.

With this new tonal destination to explore, I set out to experience what these Filtertrons could do, landing on TV Jones Classics as a well appreciated option. My first try with them involved buying a used Gretsch Electromatic Jet and swapping out the stock pickups for a set of TV Jones Classics. It was sonic bliss at first strum.

For a few months, I brought my tele style partscaster and this upgraded Gretsch to all my gigs, but the thought continued to itch - what about having one guitar with the best of both worlds. While the TV Jones Classics had great drive and a very present sound that could occupy just the right slot in a mix, there were still times that the clarity of a single coil was a better fit for a particular song or segment. Having greatly enjoyed the noiseless single-coil-style Dimarzio Area pickups for my tele partscaster, I wondered if something like a strat-inspired Area 58 could be incorporated into a guitar along with the TV Jones pickups. Since I was almost never using the first Partscaster I had put together, I decided to repurpose it to see if it could satisfy this itch.

First it needed a spot for a middle pickup

With 3 pickups, this is becoming something like a Nashville Telecaster, in which pickup selection is typically done using a strat-style 5-way blade switch. While this provides a lot of versatility in enabling different combinations of the pickups, I was interested in being able to have a neck+bridge pickup combination, similar to the original 2-pickup Gretsch. For support this combination, I decided to include a two position slider switch (the kind often found in a Jazzmaster). Here I paint it sonic blue to match the guitar's color scheme:

This would be placed in the control plate, which would have a single volume control and no tone knob. I found I basically never touch the tone control on the guitar, relying instead on using different presets in the Kemper amp. To create a slot for the 2-way switch, I drilled+cut a long slot and drilled screw holes to attach the switch.

Now it was time to wire up this frankenstein creation.

Here's the wiring diagram:

With the two position switch up towards the neck of the guitar, the 5-way blade switch cycles through the following pickup combinations:

1 - bridge

2 - bridge + middle

3 - middle

4 middle + neck

5 neck

When the slide switch is toggled to the other position (towards the lower bout), the middle and neck pickup positions are swapped in the 5-way switch, leading to the following combinations:

1 - bridge

2 - bridge + neck

3 - neck

4 - neck + middle

5 - middle

This unlocks the bridge+neck combination which would otherwise be impossible with a 5-way blade switch and 5 pickups. Another option would have been to use the two position toggle to make the neck pickups always engaged, a popular mod for strats. This would also make it possible to have all 3 pickups engaged at once. Personally I don't anticipate a need for all 3 at once, but to each their own.

Here it is wired up:

One other item worth noting, is the inclusion of a treble/tone bleed circuit that allows some of the high end frequencies to continue to cut through as the volume is turned down. This is a favorite mod I include on just about all of my guitars after learning it was included in my 2015 American Standard Telecaster.

The final pickup selection was TV Jones Classics pickups for the neck and bridge positions and a DiMarzio Area 58 (stacked noiseless) pickup for the middle slot.

There we have it, an amazingly versatile electric guitar:

With Filtertron style pickups in the neck and bridge positions, it's somewhat reminiscent of a Cabronita tele, while the third pickup makes it look a bit like a Nashville tele, hence the Nashbronitacaster. This was a rewarding build and it's been my go-to guitar since completing it a few months ago.

Polyglot - Hello World in 7 Languages

To those who love to learn languages, I understand the appeal. Being able to communicate with a wide array of people you might meet is an empowering feeling. New ideas are unlocked that had been hidden away in previously inaccessible texts.

Similarly, in the world of programming, building familiarity with other programming languages exposes you to new ideas and gives you a deeper understanding of how programs work. Possessing broad capabilities prevents becoming boxed in with opportunities limited to a narrow set of technologies - some of which are undoubtedly becoming obsolete.

To begin to get a flavor for how today's most popular programming languages are in some ways similar while also distinct, we'll look at what it takes to run what is perhaps the simplest program in most languages: a program that says Hello World.

Here are the arguably top seven languages in today's programming circles:

1. Python
2. C
3. C++
   
4. Java
5. C#
   
6. JavaScript
7. Go
   

For each, we'll take a quick look at a program that prints Hello World along with the tooling and commands required to run each sample. I'm building each of these on a Linux desktop using command-line tools. (I prefer to avoid IDEs if possible, thoughts for another time.)

 Lets hit it.

 Python

A longtime favorite of mine, I began exploring Python years ago to interview for a job and was instantly drawn to it's clean and straightforward syntax. It comes as no surprise that its popularity has steadily grown. The Python interpreter comes preinstalled in many operating systems, making it perhaps the simplest language in today's list to try out.

Here is hello-world.py:

 def main():
  print('Hello World')
  return 0
 
 
 
if __name__ == '__main__':
  main()

To run it, we can execute the command

python hello-world.py

Now experienced Python programmers may point out, this is far from the simplest Hello World program in Python. It could be as simple as 

print('Hello World')

For the sake of consistency though, we wrap our code in a main function to match the conventions present in many other languages. Also, the __name__ == '__main__' check will allow code to be executed only if the module is being run directly. It will not execute if the file is being loaded as a Python module imported by another script. 

Onward to the next:

C

This was the first programming language I've learned, which I think has been a valuable way to start. Certainly the oldest language from our list, it's still widely used today. It's comparative simplicity sometimes requires extra work, managing memory usage stands out as a clear example, but it offers a greater degree of control. When carefully written, C can offer high performance and it's often the foundation for operating systems and other programming languages. Here's a Hello World program in C hello-world.c:

#include<stdio.h>
 
int main(void) {
  printf("Hello World\n");
  return 0;
}

The C compiler is often already available in an OS (Linux and MacOS at least) so it's easy to get started. We first compile the program into an executable, and then run it. The process can look like this:

gcc -o hello-world hello-world.c

./hello-world

Neat!

C++

Next we turn our attention to a highly popular language which extends C with the cleverly named C++. When I began learning C++ in high school (at the time it was the language used in the AP Computer Science exam), it's claim to fame was the addition of classes to support Object Oriented programming, a trend which every other language in this list continues (to at least some degree). It continues to be a popular choice for high performance applications and has a wider degree of helpful language features compared to the simpler C.

When it comes to our Hello World example, the differences appear relatively minor. This is hello-world.cpp:

#include <iostream>
using namespace std;
 
int main() {
  cout << "Hello World\n";
  return 0;
}

Compiling and running was similarly straightforward compared to C. The compiler was already present in the Linux OS I was using:

g++ -o hello-world hello-world.cpp

Java

I learned Java during my first programming internship and picking it up from C++ was fairly quick. It's claim to fame was the promise to "write once, run everywhere" thanks to it's unique approach to compile Java programs into a bytecode that could be run in an interpreter. This made it one of the few languages to offer a hybrid approach to running the programs, it was initially compiled and yet also interpreted.

Here's HelloWorld.java, pretty similar to what we've seen so far with one visible difference being that this program is declared as a class, which is traditionally required for all Java programs.

public class HelloWorld {
   
  public static int main(String[] args) {
    System.out.println("Hello World");
  }
}

To run a Java program, you can use the java command which comes pre-installed in most Operating Systems. To compile the source code though, the Java Development Kit must be installed to run the Java compiler: javac.

javac HelloWorld.java 

java HelloWorld

Next up, a language that is in some ways similar to Java: C#.

C#

I recall learning about C# in college and trying it out a bit. Coming from Java, it felt very similar and this may have been intentional as the word on the street was that Microsoft had created C# as a competitor to Java when they were prevented from extending the language for use in their own applications. At the time, Java had taken the world by storm and C# brought similar ideas to the Microsoft ecosystem.

Here's a Hello World program in C#, hello-world.cs:

using System;
 
public class HelloWorld
{
    public static int Main()
    {
        Console.WriteLine("Hello World");
        return 0;
    }
}

When it comes to running the above code, the dotnet program can both compile the code and also execute the compiled program. To perfrom compilation though, the dotnet compiler requires that a project file describe the source code and the type of program to be created. Using an IDE like Visual Studio, the program file is often generated for you. Sticking to my approach though of using command line tools only, the same can be accomplished using the dotnet command when the following csproj file is in the same directory as our source code hello-world.csproj:

 <Project Sdk="Microsoft.NET.Sdk">
 
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>
 
</Project>

With the project file in place, the program can be compiled and then run using these two commands:

dotnet build
dotnet run

Next, we'll change gears to something a bit different: JavaScript.

JavaScript

While similarly named to Java, the language has very little in common. The programming syntax looks like Java, C, really most of the languages we've looked at, but under the hood it works very differently. JavaScript was initially launched as a language to run inside of Web Browsers and so it has historically been closely aligned with web applications. I started learning it when I began creating web pages and for a time I was programming in it heavily professionally. Concepts like prototypical inheritance and functions as first class objects make it possible to construct logic and dynamic behavior in JavaScript which is difficult to express in other languages.

A few years back, the NodeJS project made it possible to run JavaScript programs directly in the OS instead of being limited to only run in a browser context. This Hello World example uses the node command to interpret the following hello-world.js program:

function main() {
  console.log('Hello World');
}
 
main();

As with Python, this example is slightly more complex than strictly needed, for consistency. This program could be as short as console.log('Hello World');. 

Running this JavaScript program can be executed with the node command. which I had to install on Linux.

node hello-wolrd.js

Now we're ready for our final language Go.

Go

This is the most recent language on our list and one that I've learned over the years at work. In some ways it blends the simplicity of C with the conciseness of Python. With it's similarity to two of my favorite languages I was instantly hooked. Some of the unique design goals I recall that motivated the creation and design of Go include simplifying parallel processing - thanks to a built-in co-routine feature called goroutines - and also making it easy to reason about the flow of complex programs - hence the elimiation of throwing exceptions in favor of functions returning multiple values, one of which would be an error indicator. 

Here's a simple Hello World program in Go, hello-world.go:

package main
 
 
import "fmt"
 
 
func main() {
    fmt.Println("Hello World")
}

The compiler / interpreter for Go was already present in Linux, and running the above program was as simple as executing this command:

go run hello-world.go

Fun!

In Closing

Looking at the languages and comparing how to do the same things in each can be a fascinating exercise that deepens understanding and appreciation for how unique each programming language can be. This has been a long time fascination for me and inspired explorations like how to write classes in C, how to load libraries dynamically in Linux, and differences in how closures work in different languages. Hopefully this quick survey of Hello World examples has been instructive and inspires new explorations.

While writing the same program in 7 languages isn't the most innovative endeavor, a nice side benefit is that I now have a development environment set up for each of these languages. Another stepping stone to bigger and more exciting ideas.