Since receiving my first camera, I have taken roughly 15,000 photos. With the move towards digital cameras (and digitization of my film negatives), these take up around 100 GB1 of storage space.

That's a lot of photos.

This is the first post about those photos, focusing on the technology used to capture them.

The Film Era

My first cameras were film cameras. At the time, digital cameras couldn't match the resolution of film. The camera and optics itself were only ordinary consumer quality, but with 35mm film those cameras took somewhat decent photos.2

I've digitized this photo at around 4000x3000 pixels, which is somewhat equivalent to a 12 MP (Megapixel) digital photo.

The Transition Era

Around 2005, I got a Fujifilm FinePix A330. This ~1-3 MP3 digital camera had equivalent optics to my film camera, but the pixel resolution was strictly worse than what 35mm film would capture.

Film and digital cameras use very different principles to capture a scene into a photograph, resulting in different inaccuracies in the captured photographs.

However, as a rough rule of thumb, 35mm consumer-grade film (with equivalent lenses) can capture a scene about as good as a 12 MP digital camera. 20 MP digital cameras are roughly equivalent to professional film cameras, and around the level of detail that the human eye can perceive.4

Despite capturing photos that couldn't be magnified as much as film photos, I primarily used this camera until ~2011. I found the ability to view, delete, and retake digital photos quite helpful, resulting in me becoming a better photographer through rapid iteration. Having a digital camera was also much cheaper than having to periodically buy and develop film, even if the camera itself was more expensive upfront.

The Digital Camera Era

After succumbing to dirt and water damage, I replaced the Fujifilm FinePix A330 with a GE A1456W in 2012. This ~13 MP camera was my first digital camera with decent resolution, and a sensor good enough to take quality twilight photographs.

This was still clearly not a professional camera, but it took better photos than cell phones could at the time.

For reference, the Nokia Lumina 920, which I received in 2013, had worse optics and a smaller (~8 MP) resolution.

I didn't keep the GE camera for very long.

The GE camera wasn’t a bad camera, but it also wasn’t good enough to be competitive (GE no longer produces consumer digital cameras). It did have some features harder to find today, such as using rechargeable AA batteries instead of vendor-specific battery packs.

In 2015, I upgraded to a mirrorless Sony α5000, with a much better resolution (~20 MP), bigger sensor (APS-C), and quality optical components. This was my first digital camera with interchangeable lenses, my first camera where it clearly outperformed my own eyesight ... and the last digital camera that I have bought.

After this point in time, continual improvements in camera technology over the next ten years were not as drastic as the prior ten years, at least not in standalone digital cameras.

The Phone Era

Over the past decade, the capabilities of standalone digital cameras have made their way into phones. With a 18-55mm telephoto lens, the Sony α5000 is still superior at capturing nature at a distance5. However, mid-tier to flagship cellphones can now capture better6 wide-angle photos than my dedicated digital camera.

The most noticeable jump to me was from 2019 to 2023, when I transitioned from a moto x4 (with a 12 MP sensor roughly equivalent to the GE A1456W) to an iPhone SE (2020) (with a better 12 MP sensor), to a Pixel 7 Pro (with a ~50 MP7 telephoto and main sensor).

I'm somewhat clumsy when it comes to cell phones. Technically all three phones are still in working condition, but with minor functional damage.

Due to my clumsiness, I've replaced the Pixel with a OnePlus 13R. That phone has an equivalent main camera, but lacks the 5x optical telephoto camera that the Pixel had.

The Future Era

Personally, I find it very valuable to still have a standalone digital camera. Although I don't use it as much as I used to, the digital camera allows for much more customization and control of the photography process.

When it is time to replace my α5000, I expect to move towards something more specialized, in order that the replacement camera can do more things that modern cell phones cannot do. With that in mind, I do expect to continue to focus on cell phones with decent cameras, although hopefully my current phone will be more durable than the phones before it.

AI Predictions

It behooves me to, in a section about the future, discuss AI.

Generative AI technology is getting really good. This has started to be a problem, because generated (fake) and authentic (real) photographs are becoming harder to tell apart.

For example, here's the same rotary snowplow from the first section, but with Google's Nano Banana8 image model prompted to “add snow”:

Excessive image manipulation has always been a problem (i.e., “photoshopping”), but AI tooling allows for large-scale, bulk changes that otherwise would be impractical.

I expect initiatives such as C2PA to continue to roll out. These initiatives attempt to provide digital provenance, essentially proving that a photo is authentic. General modifications are still allowed, but either are tracked or break that provenance.

However, only a limited number of flagship devices currently support this technology, and there is only currently niche support for viewing and verifying the digital signatures associated with these images.

Subscribe now

Here is what I have learned over time from several1 microcontroller projects.

Physical limitations exist

Software

With microcontrollers, developed software is operating closer to the edges of what that hardware can do. This is a natural environment for more lower level languages (predominantly the C/C++ programming languages2), because those languages are very efficient, and easy to manipulate memory bits and bytes in.

Efficiency is important because inexpensive microcontrollers have less storage space for compiled computer code (~32 kB), and run slowly (~16 MHz). More higher level languages exist (CircuitPython, Spin), but those do tend to perform less well and also are somewhat obscure (making debugging harder).

Electronics

There also are hard limits about what the electrical hardware can do. There are only so many analog and digital outputs of a microcontroller, which can only power a relatively small amount of external circuitry.

Electrical behavior can also be unforgiving. You can attempt to drive a stepper motor directly from a microcontroller, but run the risk of frying the microcontroller in the process. There's nothing preventing you from wiring that together though, or accidentally shorting power and ground, or mixing up input and output wiring, or …

For the basics of electronics, I recommend picking up an electronics kit. For a more detailed overview, I recommend “Practical Electronics for Inventors” (Paul Scherz & Simon Monk), which is a large (but very informative) book on the topic.

Mechanics

Lastly, microcontroller projects also involve some amount of mechanical design work. This can be surprisingly difficult, especially if you want to make something kidproof(or)waterproof. Simply wiring up the project and coding it on a breadboard is helpful for prototyping, but generally not polished (or stable) enough for production use.

I've had some success with 3D printing cases for more complex projects.

Prototype everything

Getting everything right the first time is hard. Prototyping helps ensure that each piece works before you start combining them together.

Prototyping also ensures that all the electronic wiring is correct before assembling that wiring into something more tangible.

Through prototyping, you may also find your project to be good enough during that process. For example, although I've ordered custom PCBs for some projects, more recently I've been able to skip the cost (and delay) involved by getting the prototypes to that “good enough” stage.

To see the complexity and delay involved with custom PCB design, see this article.

Although no longer in fashion, I do prefer wire wrapping for the intermediate stage after breadboards, but before going to PCBs.

Consider Cost vs Conveniences

For each project, determine what the ultimate goals are for that project. Using an Arduino or component breakout board will cost more than buying a microcontroller or component chip directly. However that extra cost provides a lot of convenience, which might be worthwhile depending on the project at hand.

Arduino development includes its own development environment, which simplifies programming the microcontroller, interfacing with external components, and is popular enough to have extensive online documentation.

Buying pre-built components also lowers the skill floor for a microcontroller project, which is already considerable.

Be prepared for inconsistencies

Because this is a more esoteric programming area, be prepared to encounter issues. For example, I started developing for an Arduino Uno R4, not realizing that using I²C communication also uses analog pins 4 and 5.3

Generally, I expect documentation to be mostly right, usually quite technical, and provided libraries (if any) often arcane.

I've recently encountered this with a PN532 NFC card reader breakout board. It works just fine if you read a card but do so directly, blocking anything else from happening until a card is ready.

Putting the device into interrupt mode4 starts entering the realm where documentation is sparse, and the library calls to do so don't fully operate as expected.

Have fun

If approached correctly, microcontroller projects can be especially rewarding. I don't intend for “have fun” to be condescending, but rather to point out that there's an ocean of learning available within this space. Being able to properly explore that ocean helps if you enjoy the exploration and learning process.

I've found microcontroller projects to be interesting specifically because there is no lack of exploration possibilities, along with there being a wide variety of potential projects one can do with them.

Subscribe now

Due to where I currently live, I'm far away from the main TV broadcasters, with the geology of the area (that is, hills) interfering with TV reception.

I wanted to improve the channels my TV could receive. Although I don't frequently watch these channels, I find it useful to have access to all the major networks1 from time-to-time2, without relying on the Internet.

Existing Solutions

The default antennas built into TVs I've had were bad enough to be ignorable.

Adding an indoor TV antenna did help, but reception was still very hit or miss, with only some channels/networks coming through.

Instead of buying a more expensive outdoor antenna indoors, I decided to try and make my own antenna instead.

Designing antennas

Before making an antenna, how does one design one?

Concepts

A full discussion on the electromagnetics of antennas is well beyond the scope of this article. To summarize heavily, antennas capture the energy of electromagnetic waves traveling through space.

Measuring how well antennas work is based on how antennas match to the frequency of those waves, and the circuitry that can detect those waves.

Frequency

Antennas are designed to work for a given frequency range. For the TV stations I want to receive, I need an antenna that works for a wideband range of 186 MHz to 572 MHz.

MHz == megahertz, aka 1,000,000 cycles/second.

This antenna also needs to capture electromagnetic energy from the direction that the TV stations are. For where I am, that means I need the antenna to selectively receive 186-572 MHz frequencies within a 30° angle.

Circuitry

For a TV antenna I want to target an impedance of 300 Ω across the frequency range. Impedance matching ensures that the energy the antenna captures is transmitted to the TV, and not reflected back to the antenna.

This is usually represented in VSWR (voltage standing wave ratio), where values of 2 or lower translate to ~90% of the captured energy going from the antenna to the TV.

Interestingly, the VSWR chart and far-field chart are all that is needed to evaluate whether an antenna is good or not.

But wait, isn't bigger better?

A TV antenna is capturing a minuscule amount of the electromagnetic energy transmitted from the TV station. A bigger antenna can capture more energy, but simply making an antenna bigger will make it worse if not designed properly.

Because the minimum decent size for a TV antenna at 186 MHz is ~0.806 meters3, anything larger starts to become impractical.

These charts (and the analysis I’m doing) also ignores polarization (i.e, how the electromagnetic field is oriented) altogether. This is acceptable because DTV signals are usually horizontally polarized, and the antenna designs are also horizontal. As such, the 2D far-field chart is good enough, without me needing to take into account the polarization of the received electromagnetic field or generate 3D plots of the antenna reception performance.

Design

I'm not starting completely from scratch -- there are several different wideband antenna designs already well known and documented.

The two designs I have investigated are spiral antennas (which are wideband, but bi-directional) and log-periodic antennas (which are wideband and omnidirectional, but harder to build).

Simulating Antennas

4nec2

Previously, I have used 4nec2 to simulate a few different TV antenna designs. 4nec2 is a quite powerful and free to use4 NEC-2 implementation, with a heavy focus towards amateur radio antenna design.

NEC-2 is quite dated (having been originally designed for mainframe computers), which makes the format for designing a simulation quite more convoluted5. In addition, this is also a wire-based simulator, which is quite efficient, but makes representing antenna dishes or other solid surfaces more difficult.

However, I have managed to successfully use this program to simulate a spiral antenna (shown above), and a log-periodic antenna (below).

OpenEMS

In contrast, openEMS is a direct electromagnetic field solver, simulating electromagnetic behavior in a 3D grid. This is much more computationally intensive6, but also much more generic. As long as each grid square is small enough, any shape I like can be simulated.

Note that the 3D grid form is more coarse, but still somewhat7 the same shape.

The 3D grid-form is exported via debug_pec in FDTD.Run(Sim_Path, debug_pec=True), and visualized with ParaView. The original 3D design is visualized with AppCSXCAD, which ships with openEMS.

I've recently started to use openEMS so I can improve upon my current antenna design and more programmatically simulate the designed antennas.

Setup

Install openEMS, and the Python extensions.

• openEMS: https://openems.readthedocs.io/en/latest/install/index.html

• Python extensions: https://openems.readthedocs.io/en/latest/python/install.html

Once complete, you should have a Python virtual environment with both the openEMS and CSXCAD packages installed.

What is Python?

Python is an modern computer language, useful for prototyping and projects of all sizes.8

What is a Python virtual environment?

A Python virtual environment allows you to install Python dependent packages to a folder, without installing them to the whole computer.

Virtual environments are generally recommended so that different projects with different (potentially conflicting) dependencies can coexist on the same computer.

Configure

I had some difficulty with the installation, and had to manually set the install paths (Windows), and install + library paths (Linux)

Windows

$Env:OPENEMS_INSTALL_PATH="C:\Users\%USERNAME%\Desktop\Programs\openEMS-v36"
$Env:CSXCAD_INSTALL_PATH="C:\Users\%USERNAME%\Desktop\Programs\openEMS-v36"

Linux

export OPENEMS_INSTALL_PATH="$HOME/opt/openEMS"
export CSXCAD_INSTALL_PATH="$HOME/opt/openEMS"
export LD_LIBRARY_PATH="/usr/local/lib:$HOME/opt/openEMS/lib/"

Assuming the openEMS Python packages are accessible, the Python library import step for both systems then should work:

from CSXCAD import CSXCAD
from openEMS import openEMS

Verify

Before simulating something more complicated, I simulated a much simpler dipole antenna instead.

Despite the simplicity of the antenna, simulating this antenna requires setting up all the parameters for a much more complicated antenna. If setup successfully, simulating this antenna should match the theoretical expectations for it.

Simulation Details

Structure

With the Python openEMS extension, the entire simulation (antenna, space the antenna is in, simulation structure, result processing, etc) is defined in Python. Using Python is convenient for me, because it allows for quick debugging and iteration, along with being a computer language I am familiar with.

The remainder of this article goes over the test log-periodic simulation Python code, in detail.

Details

First, I add in Python imports, specifically openEMS, CSXCAD (geometry), numpy (math), matplotlib (charting), and built-in Python packages.

import os, tempfile

import matplotlib.pyplot as plt
import numpy as np

from CSXCAD import CSXCAD

from openEMS import openEMS
from openEMS.physical_constants import *

Set the unit to millimeters, define the center frequency, and the width. The total frequency range is f0-fc to f0+fc

unit = 1e-3

# AKA, 168 MHz to 608 MHz, Hi-V to UHF
f0 = 397.0e6
lambda0 = round(C0/f0/unit)  # Wavelength in mm
fc = 211e6

Define the simulation size. It has to be at least as big as the largest wavelength9, but also decently far enough away from the antenna structure itself (wavelength/4 from here).

SetGaussExcite uses the previous frequency information to define the wideband simulation.

Lastly, this also sets up how the wall edges are simulated, where I’ve gone for accuracy over speed.

# This is a rather wide frequency range, so go overkill on box size
SimBox = np.array([2.0, 2.0, 8.0])*2.0*lambda0

FDTD = openEMS()
FDTD.SetGaussExcite(f0, fc)

# MUR is faster, but do PML_* everywhere for better accuracy
FDTD.SetBoundaryCond( ['PML_8', 'PML_8', 'PML_8', 'PML_8', 'PML_8', 'PML_8'] )

Create a geometry instance and associate it with the simulation. Also compute the minimum cell size for geometry, which is also based on wavelength as specified here.

CSX = CSXCAD.ContinuousStructure()
FDTD.SetCSX(CSX)
mesh = CSX.GetGrid()
mesh.SetDeltaUnit(unit)

max_res = np.floor(C0 / (f0+fc) / unit / 20)

# Go even smaller to properly account for the small dipoles and wires in my antenna, which are smaller than they really should be, but it is what I have already physically built.
dipole_min_res = 3.2  # Radius, mm
supporting_wire_min_res = 0.4 # Also radius, in mm

With all that information, define the 3D grid structure by specifying where (in x, y, and z) there need to be lines that break apart cells into smaller cells.

Specifically, this logic ensures that the spiral connecting wire is at a very high resolution, the dipoles are at a medium resolution, and outer air is at a low resolution.

center_feed_radius = 10

# These are both precomputed in a later step and then stored here
antenna_z_range = 592
antenna_y_range = 540

mesh.AddLine('x', [-center_feed_radius, center_feed_radius])
mesh.AddLine('y', [-center_feed_radius, center_feed_radius])
mesh.AddLine('z', [-antenna_z_range, antenna_z_range])

mesh.SmoothMeshLines('x', supporting_wire_min_res)
mesh.SmoothMeshLines('y', supporting_wire_min_res)
mesh.SmoothMeshLines('z', supporting_wire_min_res)

mesh.AddLine('x', [-antenna_y_range, antenna_y_range])
mesh.AddLine('y', [-center_feed_radius , center_feed_radius])

mesh.SmoothMeshLines('x', dipole_min_res)

mesh.AddLine('x', [-SimBox[0]/2,  SimBox[0]/2])
mesh.AddLine('y', [-SimBox[0]/2,  SimBox[0]/2])
mesh.AddLine('z', [-SimBox[0]/2,  SimBox[0]/2])

mesh.SmoothMeshLines('x', max_res)
mesh.SmoothMeshLines('y', max_res)
mesh.SmoothMeshLines('z', max_res)

Using the CSXCAD geometry system, define the antenna dipoles and connecting wire

antenna_metal = CSX.AddMetal('antenna')
wire_lengths = [
    53, # Smallest, 1
    61,
    79,
    97,
    121,
    150,
    180,
    230,
    280,
    335,
    413  # Largest, 11
]

wire_separation = [
    41, # From 1-2
    50,
    59,
    75,
    91,
    111,
    135,
    179,
    203,
    238
]

antenna_x = []
antenna_y = []
antenna_z = []

# Center the antenna. This is *important*, because proper far-field analysis assumes the antenna structure is centered.
current_pos_z = sum(wire_separation) / 2.0
start_pos_z = current_pos_z

HELIX_HALF_TURNS = 12 # To represent a helix, use 24 line segments for each 360 degree circle.
for i, wire_length in enumerate(wire_lengths):
    # Symmetrical dipoles
    antenna_metal.AddWire(np.array([
        np.array([center_feed_radius, center_feed_radius + wire_length]),
        np.array([0.0, 0.0]),
        np.array([current_pos_z, current_pos_z])]), dipole_min_res)
    antenna_metal.AddWire(np.array([
        np.array([-center_feed_radius, -(center_feed_radius + wire_length)]),
        np.array([0.0, 0.0]),
        np.array([current_pos_z, current_pos_z])]), dipole_min_res)

    if i < len(wire_separation):
        # Create the curved pieces to the next part of the dipole
        helix_points = np.linspace(0, np.pi, HELIX_HALF_TURNS)
        x_points = center_feed_radius*np.cos(helix_points)*1.05
        y_points = center_feed_radius*np.sin(helix_points)*1.05
        z_points = current_pos_z - (helix_points/np.pi)*(wire_separation[i])
        antenna_metal.AddWire(np.array([x_points, y_points, z_points]), supporting_wire_min_res)

        # and do the same thing for the offset dipole too
        helix_points = np.linspace(np.pi, 2*np.pi, HELIX_HALF_TURNS)
        x_points = center_feed_radius*np.cos(helix_points)*1.05
        y_points = center_feed_radius*np.sin(helix_points)*1.05
        z_points = current_pos_z - ((helix_points - np.pi)/np.pi)*(wire_separation[i])
        antenna_metal.AddWire(np.array([x_points, y_points, z_points]), supporting_wire_min_res)

        # Move up
        current_pos_z = current_pos_z - wire_separation[i]

Define a feed port, which is where the antenna signal is received. openEMS simulates transmitting from our antenna by powering the feed port, which (because antennas are symmetrical systems) then simulates how well the antenna does at receiving the same signal.

This feed port partially overlaps the antenna structure, which ensures that it connects to it. It has a higher “priority” so that the feed port is prioritized and replaces the antenna, instead of the antenna replacing the feed port.

offset = 12
port_spacing = center_feed_radius + offset
start = [-port_spacing, -1, start_pos_z - 5]
stop  = [port_spacing, 1, start_pos_z + 5]

feed_resistance = 300  # ohms
port = FDTD.AddLumpedPort(1, feed_resistance, start, stop, 'x', 1.0, priority=5)

Lastly, ensure that the near field information is captured, save the antenna structure, and run the simulation.

nf2ff = FDTD.CreateNF2FFBox(opt_resolution=[lambda0/15]*3)

# For debugging purposes, write the antenna to a file
CSX_file = os.path.join(Sim_Path, 'log-periodic.xml')
CSX.Write2XML(CSX_file)

FDTD.Run(Sim_Path)

Once the simulation completes, graph it! This section uses the port information to graph the VSWR:

# Use 501 points for the frequency range
freq = np.linspace(f0 - fc, f0 + fc, 501)
port.CalcPort(Sim_Path, freq)

Zin = port.uf_tot / port.if_tot
s11 = port.uf_ref / port.uf_inc

vwsr = (1 + np.abs(s11)) / (1 - np.abs(s11))

## Plot VSWR, saving the plot to a file too
plt.figure()
plt.plot(freq/1e6, vwsr, 'k-', linewidth=2)
plt.grid()
plt.title('VSWR')
plt.xlabel('frequency (MHz)')
plt.ylabel('VSWR')
plt.savefig(os.path.join(Sim_Path, 'vwsr.png'))

And lastly, compute the far-field antenna information and graph the antenna directivity over multiple frequencies.

theta = np.arange(0.,360.,2.)
phi = np.array([0])

# Define a few frequencies of interest
nf2ff_res = nf2ff.CalcNF2FF(Sim_Path, [f0 + fc/2, f0 - fc/2, f0, f0-fc/4, f0+fc/4], theta, phi)

plt.figure(figsize=(8, 8))
ax = plt.subplot(111, projection='polar')
theta_rad = np.deg2rad(theta)
for freq_idx in range(len(nf2ff_res.freq)):
    powerPlot = nf2ff_res.E_norm[freq_idx]/np.max(nf2ff_res.E_norm[freq_idx])
    ax.plot(theta_rad, powerPlot[:,phi==0], linewidth=2, label=f'$|E|$ {nf2ff_res.freq[freq_idx]/1e6}')

ax.set_title('Far field patterns')
ax.legend()
ax.grid(True)
plt.savefig(os.path.join(Sim_Path, 'polar-pattern.png'))

# Show all the plots generated so far
plt.show()

And that’s it! I’ve personally reordered this structure somewhat (because once the simulation is complete, you can skip the FDTD.Run(…) step to read the prior results and perform different charting+analysis). However, this is essentially the steps I’ve used to simulate the log-periodic antenna I have in openEMS, and what I plan to use for future simulations.

CM Log Periodic UHF/VHF antenna design
CM Gustave Granroth 6-26-2022
CE
SY MinFreq = 176
SY MaxFreq = 618
SY FreqSteps = (MaxFreq - MinFreq) / 10
SY ZPos = 0
SY WireSegments = 7
SY FeederSegments = 3
SY TubeRadius = 0.003175 'Copper tubing
SY WireRadius = 0.000511 'Magnet wire
SY HalfSpacing = 0.01 'Configurable properties start here
SY HL9 = 0.038 '= 0.426, long boom
SY HL8 = 0.038
SY HL7 = 0.038
SY HL6 = 0.038
SY HL5 = 0.038
SY HL4 = 0.038
SY HL3 = 0.038
SY HL2 = 0.038 
SY HL1 = 0.038
SY HL0 = 0.121 'Say ten booms total, this is the short boom
SY SP0 = 0.1
SY SP1 = 0.1
SY SP2 = 0.1
SY SP3 = 0.1
SY SP4 = 0.1
SY SP5 = 0.1
SY SP6 = 0.1
SY SP7 = 0.1
SY SP8 = 0.1
SY SP9 = 0.1
GW	1	3				0		-HalfSpacing	ZPos		0		HalfSpacing		ZPos	WireRadius	'Driver
GW	2	WireSegments	SP0		-HL0			ZPos		SP0		-HalfSpacing	ZPos	TubeRadius	'Boom1,L
GW	3	WireSegments	SP0		HalfSpacing		ZPos		SP0		HL0				ZPos	TubeRadius	'Boom1,R
GW	4	WireSegments	SP0+SP1	-(HL0+HL1)	ZPos			SP0+SP1	-HalfSpacing	ZPos	TubeRadius	'Boom2,L
GW	5	WireSegments	SP0+SP1	HalfSpacing	ZPos			SP0+SP1	HL0+HL1	ZPos	TubeRadius	'Boom2,R
GW	6	WireSegments	SP0+SP1+SP2	-(HL0+HL1+HL2)	ZPos			SP0+SP1+SP2	-HalfSpacing	ZPos	TubeRadius	'Boom3,L
GW	7	WireSegments	SP0+SP1+SP2	HalfSpacing	ZPos			SP0+SP1+SP2	HL0+HL1+HL2	ZPos	TubeRadius	'Boom3,R
GW	8	WireSegments	SP0+SP1+SP2+SP3	-(HL0+HL1+HL2+HL3)	ZPos			SP0+SP1+SP2+SP3	-HalfSpacing	ZPos	TubeRadius	'Boom4,L
GW	9	WireSegments	SP0+SP1+SP2+SP3	HalfSpacing	ZPos			SP0+SP1+SP2+SP3	HL0+HL1+HL2+HL3	ZPos	TubeRadius	'Boom4,R
GW	10	WireSegments	SP0+SP1+SP2+SP3+SP4	-(HL0+HL1+HL2+HL3+HL4)	ZPos			SP0+SP1+SP2+SP3+SP4	-HalfSpacing	ZPos	TubeRadius	'Boom5,L
GW	11	WireSegments	SP0+SP1+SP2+SP3+SP4	HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4	HL0+HL1+HL2+HL3+HL4	ZPos	TubeRadius	'Boom5,R
GW	12	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5	-(HL0+HL1+HL2+HL3+HL4+HL5)	ZPos			SP0+SP1+SP2+SP3+SP4+SP5	-HalfSpacing	ZPos	TubeRadius	'Boom6,L
GW	13	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5	HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5	HL0+HL1+HL2+HL3+HL4+HL5	ZPos	TubeRadius	'Boom6,R
GW	14	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6	-(HL0+HL1+HL2+HL3+HL4+HL5+HL6)	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6	-HalfSpacing	ZPos	TubeRadius	'Boom7,L
GW	15	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6	HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6	HL0+HL1+HL2+HL3+HL4+HL5+HL6	ZPos	TubeRadius	'Boom7,R
GW	16	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	-(HL0+HL1+HL2+HL3+HL4+HL5+HL6+HL7)	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	-HalfSpacing	ZPos	TubeRadius	'Boom8,L
GW	17	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	HL0+HL1+HL2+HL3+HL4+HL5+HL6+HL7	ZPos	TubeRadius	'Boom8,R
GW	18	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	-(HL0+HL1+HL2+HL3+HL4+HL5+HL6+HL7+HL8)	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	-HalfSpacing	ZPos	TubeRadius	'Boom9,L
GW	19	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	HL0+HL1+HL2+HL3+HL4+HL5+HL6+HL7+HL8	ZPos	TubeRadius	'Boom9,R
GW	20	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9	-(HL0+HL1+HL2+HL3+HL4+HL5+HL6+HL7+HL8+HL9)	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9	-HalfSpacing	ZPos	TubeRadius	'Boom10,L
GW	21	WireSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9	HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9	HL0+HL1+HL2+HL3+HL4+HL5+HL6+HL7+HL8+HL9	ZPos	TubeRadius	'Boom10,R
GW	22	FeederSegments	SP0	-HalfSpacing	ZPos			SP0+SP1	-HalfSpacing	ZPos	WireRadius	'Feeder2,L
GW	23	FeederSegments	SP0	HalfSpacing	ZPos				SP0+SP1	HalfSpacing	ZPos	WireRadius	'Feeder2,R
GW	24	FeederSegments	SP0+SP1	-HalfSpacing	ZPos			SP0+SP1+SP2	-HalfSpacing	ZPos	WireRadius	'Feeder3,L
GW	25	FeederSegments	SP0+SP1	HalfSpacing	ZPos				SP0+SP1+SP2	HalfSpacing	ZPos	WireRadius	'Feeder3,R
GW	26	FeederSegments	SP0+SP1+SP2	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3	-HalfSpacing	ZPos	WireRadius	'Feeder4,L
GW	27	FeederSegments	SP0+SP1+SP2	HalfSpacing	ZPos				SP0+SP1+SP2+SP3	HalfSpacing	ZPos	WireRadius	'Feeder4,R
GW	28	FeederSegments	SP0+SP1+SP2+SP3	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4	-HalfSpacing	ZPos	WireRadius	'Feeder5,L
GW	29	FeederSegments	SP0+SP1+SP2+SP3	HalfSpacing	ZPos				SP0+SP1+SP2+SP3+SP4	HalfSpacing	ZPos	WireRadius	'Feeder5,R
GW	30	FeederSegments	SP0+SP1+SP2+SP3+SP4	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5	-HalfSpacing	ZPos	WireRadius	'Feeder6,L
GW	31	FeederSegments	SP0+SP1+SP2+SP3+SP4	HalfSpacing	ZPos				SP0+SP1+SP2+SP3+SP4+SP5	HalfSpacing	ZPos	WireRadius	'Feeder6,R
GW	32	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6	-HalfSpacing	ZPos	WireRadius	'Feeder7,L
GW	33	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5	HalfSpacing	ZPos				SP0+SP1+SP2+SP3+SP4+SP5+SP6	HalfSpacing	ZPos	WireRadius	'Feeder7,R
GW	34	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	-HalfSpacing	ZPos	WireRadius	'Feeder8,L
GW	35	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6	HalfSpacing	ZPos				SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	HalfSpacing	ZPos	WireRadius	'Feeder8,R
GW	36	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	-HalfSpacing	ZPos	WireRadius	'Feeder9,L
GW	37	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7	HalfSpacing	ZPos				SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	HalfSpacing	ZPos	WireRadius	'Feeder9,R
GW	38	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	-HalfSpacing	ZPos			SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9	-HalfSpacing	ZPos	WireRadius	'Feeder10,L
GW	39	FeederSegments	SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8	HalfSpacing	ZPos				SP0+SP1+SP2+SP3+SP4+SP5+SP6+SP7+SP8+SP9	HalfSpacing	ZPos	WireRadius	'Feeder10,R
GW	40	FeederSegments	0	-HalfSpacing	ZPos			SP0	-HalfSpacing	ZPos	WireRadius	'Feeder2,L
GW	41	FeederSegments	0	HalfSpacing	ZPos				SP0	HalfSpacing	ZPos	WireRadius	'Feeder2,R
GE	0
GN	-1
EK
EX	0	1	2	0	1	0	0	'First wire overall, with tag 1
FR	0	0	0	0	566	0
EN

7

A more precise 3D grid results in the following design view and 3D mesh view:

Using this more precise mesh extends the computation time even further, from 10 minutes to ~240 minutes.

Admittedly, this mesh is suboptimal, in that I am using too small grid cells and throwing computer time (and RAM) at the problem, instead of making the mesh more detailed only where it needs to be so.

Factorio is a factory simulation game. The goal of the game is to go from the starting planet to a point in space1, which requires producing several game items to perform.

At the beginning, items can be produced by hand, but rapidly start requiring specialized machines to produce (i.e., smelting iron ore into into iron plates), along with belts+trains to automate bulk production

This bulk production is what makes Factorio a factory simulator. For example, building the rocket silo (which is necessary to build rockets to go to space) requires massive amounts of several items, which themselves are made up of other items.

To complicate matters further, there are also enemies in Factorio. These enemies are attracted to the pollution created by the factory components, destroying the factory if not otherwise protected. As such, some of the factory production has to go towards defense, in addition to factory expansion and resource extraction.2

Factory design

Because Factorio is a factory simulator, factory design is really what the game is about. Personally, I enjoy the bounded puzzles that come about from this structure. Factorio’s emphasis on automation and problem solving also makes this a more commercial education game than usual, although it still is definitely a recreational video game.

Early designs

In the beginning, playing Factorio is an exercise in discovery. My early factory designs reflected that, where resources are plumbed all over the place to flow to the machines where they were necessary. I didn't use drones, and also struggled to properly route trains to avoid signaling deadlocks.

Factorio drones will automatically build planned factory sections using stored resources. They can help with literal Copy+Paste of pieces of the map, but are most useful copying stored sections for reuse.

However, using drones requires building drones. There are also limitations as to where and how drones work, so there's a moderate upfront cost to start using drones at all.

Intermediate Designs

Over time, I swapped to a “main belt” design, with minimal drone usage. This resulted in a more ordered (and productive) factory, although with still a moderate amount of manual (non-automated) creation of the factory itself.

Zooming out a bit shows a more iconographic view of the same map

This point in time is roughly when I bought the Space Age expansion. This expansion added space travel, with space ships and new planets to explore.

I also began experimenting with even larger, more automated base expansion at this time.

These designs were sufficient for me to finish Factorio (and Factorio with the Space Age expansion), which put a pause in my factory designing for a while.

Current Designs

More recently (~late 2025), I began revisiting Factorio with the goal of further automating factory production. That has resulted in new designs with a similar, but much different grid structure.

This grid structure is formed with drone hubs, that themselves enclose a train network. Adding a new grid square automatically links those rails (and any components within it) to the rail network.

This has made base expansion more practical, because I can directly copy+paste trains (moving resources around) with their stations (processing those resources into new products). There are some caveats with this design3, but overall I’m glad with the simplicity and increase in automation that this has provided.

Final thoughts

Tips

Most of the tips I've learned from this game come from experimentation (which I highly recommend) or Trupen on YouTube (especially some of his longer, more generic videos).

Other than the pithy “have fun” tip, I personally recommend using keyboard shortcuts, to more easily shuffle resources and copy machine settings around.

Game Comparison

Factorio is now the most played game in my Steam library, surpassing my playtime in FTL: Faster than Light by roughly 50 hours. Factorio has building aspects similar to Sim City 3000, Cities: Skylines, and RollerCoaster Tycoon. However, it also has notable resource constraints and the need to balance expansion and defense, similar to Civilization IV4 and Warzone 21005. It's a game I find decently replayable, with manageable complexity.

Factorio does lack a narrative, or story beyond that which you infer it to be. It's not a Mass Effect or Baldur’s Gate 3, nor would it be a Skyrim. It's also not a combat focused FPS, such as the Crysis or Halo series. That is to say, this isn't the only video game that I will continue to play, but is is one I continue to enjoy.

3

Caveats:

• Trains can’t detect when they need to refuel (without mods), so there’s a special ‘refueling’ stop that each train needs to visit somewhat frequently.

• Trains prefer the closest free stop, so if there’s a shortage of Iron and multiple trains delivering Iron to multiple destinations, those destinations aren’t served equally.

  • In other words, this design doesn’t work well when there are resource shortages, because parts of the factory operate optimally and some parts not at all. My earlier “main belt” based designs result in a factory that overall performs sub-optimally during resource shortages.

• There’s a decent amount of unused space in some of the grid squares.

For more information on coding itself, see my previous post

Purpose

If I was to summarize code reviews into two core values, I would choose “experience and trust”.

Experience

For all developers, code reviews provide a space for other developers to detect flaws before those flaws impact customers. Code reviews don't take the place of manual or automated testing, because that's something all developers should be doing anyways for their changes.1 Flaws that make their way into code reviews tend to be situations that testing hasn't caught, incorrect solutions to the problem, structural flaws in the code change itself, or general clarity issues.

For newer and more inexperienced developers, code reviews allow for those developers to learn from more experienced developers on how to write better code. While more tenured and experienced developers should have fewer flaws in their code changes2, mistakes will happen and there is always the ability to learn from others.

Testing gaps

Even with good test coverage3, there can be rare situations that code doesn't properly handle. These are either known software situations, unknown technical limitations, or knowledge gaps.

Known software situations: Dividing by zero, using data that has already been deleted, trying to modify data that is in the process of being modified, etc.

Technical limitations: Using feature XYZ, which is only supported in version 1.3 of ABC, not version 1.24

Knowledge Gaps: Updating code in section A requires a corresponding change in section B, Alice and Bob only accept changes in section C with prior approval, etc.

Code reviews ensure that these gaps are detected, to fix problems before users encounter them.

Incorrect solutions

Due to the ambiguity inherent in translating ideas into the structural process of code, the code submitted for review may solve the wrong problem.

From my experience writing software, the best defense against this problem is ensuring code reviews are small. Even if a small code change5 doesn't solve the root problem, the incremental step helps other reviews ensure the changes are progressing to the right solution.

Structural flaws

Similar to incorrect solutions, structural problems can happen in code that otherwise is fully functional. Usually, structural problems consist of code that solves the original problem, but either doesn't generalize to similar problems or isn't designed to support further modification.

Clarity issues

Lastly, functional code for review can be unclear. While clarity isn't a flaw in and of itself, lack of clarity increases the likelihood for future flaws to be introduced.

To improve clarity, teams I have worked with have guidelines for style (see spaces vs tabs), enforced manually or with automated tooling. Personally, I'm in favor of automated style management, but if that isn't an option (or there are conflicting & inconsistent style preferences) I prefer staying consistent with any existing code that I am changing.

Trust

The other core reason for code reviews is to ensure that at least one other coworker sees a change before it is actually made official. This reflects a more modern increase in trust management (i.e., “trust but verify”), along with a more broader awareness of computer security.

Trust Management

As an industry, having mandatory code reviews is still a relatively new concept6. While I believe code reviews are generally beneficial, using them as an access control mechanism solves a tangential problem.

The more direct problem is “why would an untrustworthy individual be granted access to make code changes at all”?

With open source projects, often the broad public can submit code changes, but only trusted/verified maintainers can perform the review and approve those code changes.7

For corporate projects, usually code changes are restricted to a core group of team members. Although all team members of that group should be trusted, requiring another reviewer avoids compliance issues, and ensures that someone else does in fact formally review a code change.

Security

Having mandatory code reviews ensures that multiple individuals are required to make any changes, which avoids attacks from a single compromised individual (example). With larger companies and broad access groups, this policy does improve the overall security posture and prevent supply chain attacks.

AI

How does the advent of LLMs+AI affect code reviews?

AI will certainly increase the number of code reviews, but also brings up the question of what counts as “review”.

Generally, I believe that all AI-generated code should be human reviewed. AI code reviewers can assist with the review process, along with automated testing.

I've recently been convinced that AI-generated code should have full code coverage, because generating and verifying that coverage is an automated process that AI can generally iterate well on.

This code coverage alone doesn't prove code correctness though. For more information on that, see footnote 3.

However, I still think there should be a human reviewer, because otherwise the AI code reviewer (and company behind the AI model performing the review) effectively is operating as a full employee. Trusting an AI reviewer alone introduces the liability and security issues previously discussed in the “Trust” section.

Ending Thoughts

It is important for me to call out that code reviews are intended to result in better code. When I was a newer developer, I remember feeling discouraged at the amount of comments from the code reviews I would submit. Those comments are not intended to be personal attacks, or a reflection of competency, but rather are to improve the current code and code that you later write.

Subscribe now

// Code
Add(x, y):
  return 4

// Test
TestAdd():
  abort if Add(2,2) is not 4

I like my clothing like I like my cars: delightfully boring. In general, this means functional clothing matching the social setting I am in, without conveying any overtly political or social messages with that clothing.

In practice, achieving all of those goals is actually quite difficult. I've expanded upon why in each section below.

I also dislike the clothes buying process, resulting in a tendency to reuse clotheing matching my preferences until that clothing is past its lifespan.

Because of that, I am exceedingly grateful for my family, who know that I enjoy receiving clothing for birthdays and Christmas.

Political messaging

Over the last several years face masks, white polo shirts, red shirts, and red hats have become partially politicized. These aren't all clothing items I would normally wear, but do mean I can't blindly wear clothing to work without checking that it won't inadvertently convey a message.

Because I really don't want my clothing to reflect any political views I have, I am extremely cautious to avoid any implications from what I wear. For example, I avoid wearing jeans with a yellow polo, because that matches the Ukrainian flag.

Similarly, I avoid white shoes, jeans, and a red polo because unless it is Independence Day (July 4th), those colors are potentially conflated with the American flag and Russian flag.

Social messaging

Because clothing does reflect upon the wearer, there are minimal standards I need to have. Specifically, this means that the clothing I wear can't be too expensive, too worn, too fancy, or too simple.

Too expensive

I'm not a fashionista. While I do enjoy quality clothing, anything too expensive1 doesn't accurately reflect my personality and starts becoming a fashion statement instead of boring.

Too worn

At the other end of the spectrum, any clothing too worn stops being sufficiently functional. Similarly, although deliberately worn clothing can be a fashion statement, it's not one I would like to pull off and also would be categorized as “not boring” clothing.

Too fancy

To me, this means wearing clothing appropriate for the occasion. On the fancy end of the spectrum this currently means no suits at work2, but always suits at weddings. Similarly, expensive watches3 are both too expensive and too fancy, but watches in general (especially functional sports watches) are appropriate.

Too simple

Excessively simple clothing can also convey a social statement. In particular, this means that basic white sneakers are no longer part of my clothing repertoire.

This preference also means that I prefer to be dressed for the occasion, neither over-dressed nor under-dressed.

Functional clothing

Lastly, I want clothing I own and use to be functional. Although men's clothing is usually functional4, there are certain aspects of clothing that can make it more or less functional.

Cut

Some cuts of mens clothing are more stylish, but less functional. For example, jeans can come in multiple styles, some of which fit my body type better.

Personally for jeans, I prefer the “basic” or “relaxed” styles, because those tend to offer a good fit without being too restrictive or baggy.

Material

Another indication of functionality for the clothing I wear is the material it is made of. In brief, I prefer wearing cotton fabrics.5

I do have (and wear) clothing made of other materials (polyester, wool, etc). However, I do prefer cotton because it is comfortable, breathes well, is reasonably durable, and is decently priced.

However, I generally don't prefer wearing synthetic cloth-based clothing. In particular, I dislike rayon/bamboo viscose, because that fabric feels unnaturally plastic, and doesn't dry consistently in a dryer load.

Bamboo viscose is essentially rayon, derived (with heavy chemical processing) from bamboo instead of other plants. The confusion over this newer fabric has resulted in the FTC clarifying that only fabric actually made from bamboo fibers can be called “bamboo”

• How I translate general ideas into concrete structural processes

• The process of writing human-readable text to describe those processes

• Part of my job as an industrial software developer1

Before I discuss coding further, it's worthwhile to see what the rest of the Internet defines coding to be.

Computer programming or coding is the composition of sequences of instructions, called programs, that computers can follow to perform tasks

Wikipedia, directly referencing Shaun Bebbington

Coding is telling a computer what to do, in a way that, with a bit of translation, it can understand.

University of York

Why do we need coding?

This sounds like a straightforward question, but it somewhat summarizes how far general computing devices have come in the last several decades.

Coding allows a general computing device to perform many different tasks, based on the program installed on that device. Phones and computers are the most well-known examples nowadays, with their plethora of apps for banking, gaming, music, and so on.

Coding has become prevalent in our lives partly because computers have become cheaper, smaller, and faster; all-around better. There are great historical examples of how computers used to be larger2, more expensive, and specialized, but for this article I'll discuss dishwashers!

The dishwasher

The first dishwasher I can remember using was entirely electromechanical. You'd turn the switch to the desired cleaning setting, and it'd slowly rotate to the Off state, going through the rinse-clean-rinse-dry process.

At the time, this was the efficient (and cheap) design, with the operating decisions (how long to rinse, clean, etc) defined by the mechanical clock triggered by the dial.

However, as computers have become cheaper, modern dishwashers have removed those mechanical controls3, generally opting for buttons (or a capacitive panel with button stickers). Coding allows the computer in the dishwasher to perform the necessary steps to clean the dishes.

It can be odd to think of a dishwasher as having a computer, but something has to control how that dishwasher operates. That computer doesn't need to be especially complicated or powerful, because there's not that much data a dishwasher needs to process or store.

For example, a hobbyist friendly microcontroller (computer-on-a-chip) is currently ~$1.50. It doesn't look like a computer, but it has enough complexity to blink a light, act as a synthesizer ... or run a dishwasher.

Why do computers need coding?

Computers need code because computers themselves are essentially complicated calculators, with more inputs, storage, compute power, and outputs

How computers work really deserves its own article, but in brief, computers need code to orchestrate what happens inside the machine to control its outputs based on its inputs and stored data.

What is coding?

Translating general ideas

At work or home, coding usually begins with a problem. That problem (“customer ABC can't do XYZ”, “I want to graph data DEF programmatically”) serves as the baseline for determining what to code.

With analysis, each problem is broken down into smaller, manageable pieces that can each be solved to complete the underlying problem. This analysis process also serves to triage and prioritize the problem, clarify any assumptions, and prepare the problem for implementation.

In a work context, this translation and analysis process breaks a problem from “single person+experienced developer” to “multiple people+junior developers”. As developers grow in experience, being able to subdivide problems and hand them off to others is a key part of their growth.4

Writing human-readable text

Writing code, despite being the most visible part of the software development process, is only ~20-30%5 of the job.

Any code I (or an AI6) creates has to at least work. However, that's an insufficiently low bar for industrial software. At a minimum, I expect any code I create or review to work, be tested in some form, have a sufficient explanation, and be consistently clear (in line with related existing code)7.

The most important aspect in code production is clarity. Clarity is important because for large software projects, other people (or myself years later) need to be able to comprehend the changes I make.

How can functional code be unclear?

Computers operate by executing machine instructions. These instructions are extremely basic, so there exist a wide variety of software languages to abstract away those instructions and provide for some common functionality.

Functional code can be unclear because software languages provide for different means of accomplishing the same task.

Even when using machine instructions (assembly language), there are different ways to solve several problems.

For example, 2*3 can be done via multiplication, but performing 3+3 has the same result.8

Part of my job

Lastly writing code solve problems, but those problems themselves come from some overarching goal.

Work provides a structure with goals, which has guided my growth in software development over the years. This career has expanded my understanding of coding well beyond what it was when I first started working. Essentially, I feel better able to answer the question of “what is coding?” through having has the experiences and career I have had so far.

Although my experience won't be applicable to everyone, I believe that achieving goals through programming is a universal part of what coding can be.

Epilogue

As a final thought, I hope it is not too surprising for this article to discuss what is coding without showing code examples.9

After all, this isn't an article on how to code (or how to read code), both of which are lengthy enough to deserve their own article.

Subscribe now

This article discusses creating a VPN connection to your local home network, not how to use a commercial VPN service for anonymity or to access the internet from other countries.

Background

My home network setup currently looks something like this:

Crucially, the home router limits connectivity with the outside world. Only Minecraft players can directly access my home Minecraft server, because the router is configured to let that traffic from the Internet through.

For my friends, this is sufficient. My friends can directly access my Minecraft server using this configuration, with their network connection to my server looking something like this:

Recently though, I've wanted to access more locally hosted resources1 from my home network over the internet. For more comprehensive access to my home network, I setup WireGuard VPN.

What does WireGuard do?

WireGuard provides a somewhat easy (but quite technical) means to connect multiple devices to a secondary “virtual private network” (aka “VPN”). The end result is to connect my over-the-internet remote device to that network, and my server to that same virtual network.

This connection allows my remote device to access my local home devices through the virtual network, as if my remote device were another device on my local home network.

Setup

Installation

For the at home server, install WireGuard using the instructions here.

Assuming the remote device is a phone, download the Android app or iPhone app.

Configuration - General

Select a port, such as 345672, for WireGuard usage. Forward that port through your router to the home server IP (assumed to be as 10.95.1.121), using whatever configuration mechanism your router manufacturer has provided.

Determine your home network internet IP (assumed to be 73.74.75.763).

Generate the public/private encryption keys for the server, using the following command.

$ wg genkey > server.private_key  # private key saved in "server.private_key"
$ wg pubkey < server.private_key
PUBLIC_KEY_OUTPUT_HERE

Lastly, choose a virtual network prefix, such as 10.12.12.4

With all of this general configuration out of the way, we can now configure a client.

Configuration - Client

Assuming this is the first client, assign it ID 2, resulting in a virtual IP of 10.12.12.2/245

Using the configuration details from the last section, configure the client. As an example, in the Android application the configuration would look like:

This configuration assumes that the client is allowed to connect to anything through the VPN, with “Allowed IPs” set to 0.0.0.0/0.

Copy the “Public key” generated in the client, for use in setting up the server.

Configuration - Server

Using the general configuration details and client public key, configure the server.

For Linux, create /etc/wireguard/wg0.conf as root and edit it as follows6:

[Interface]
# Aka the server IP, but also allowing for 10.12.12.2,3,4,etc.
Address = 10.12.12.1/24
PostUp = iptables -A FORWARD -i %i -j ACCEPT; iptables -A FORWARD -o %i -j ACCEPT; iptables -t nat -A POSTROUTING -o enp191s0 -j MASQUERADE
PostDown = iptables -D FORWARD -i %i -j ACCEPT; iptables -D FORWARD -o %i -j ACCEPT; iptables -t nat -D POSTROUTING -o enp191s0 -j MASQUERADE
ListenPort = 34567
PrivateKey = SERVER_PRIVATE_KEY
[Peer] # Allow the client to connect to the VPN
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.12.12.2/32

This configuration allows the server to forward traffic over the local Ethernet connection (enp191s0) and only allows the server to connect to the client (10.12.12.2/32)

Enable

Enable the server by running:

sudo wg-quick up wg0

Enable the client by toggling the VPN switch

If everything is correct the server should show

interface: wg0
  public key: SERVER_PUBLIC_KEY
  private key: (hidden)
  listening port: 34321

peer: PEER_PUBLIC_KEY
  allowed ips: 10.123.45.165/32

: and the client should show:

Results

After all of this setup, in your phone’s browser-of-choice you can now go to 10.95.1.121, and access anything on that computer as if you were at home!

Back in 2023, we paid for an upgrade to our house’s HVAC system. At the time, we installed an air conditioner because my math indicated it made the most economic sense.

Were my calculations correct?

What is a heat pump?

A heat pump is essentially a reversible air conditioner. In addition to cooling the house in the summer (by transferring the heat outside), heat pumps heat the house in the winter (by transferring the heat inside).

Heat pumps are more efficient than a resistive heater (aka, a space heater (or toaster)) because they use electricity to move existing outdoor heat indoors. Moving existing energy (heat) takes less electricity than converting electricity directly into heat.

Calculations

Fuel costs

As of late 2025, PSE (Puget Sound Energy) charges approximately $0.20 per kWh of electricity,1 and $1.66 per therm of natural gas.2

Resistive heating

Each therm is equivalent to 29.3 kWh of heat. Although resistive heating is essentially 100% efficient, replacing 120 therms of natural gas heating ($1.66*120/0.95=$210)3 with resistive heating ($0.20*29.3*120=$703) is not economical.

However, this does give a minimum bar for what would be economical. A heat pump that is 3.4x as efficient ($703/$210=3.35) would start being competitive with natural gas heating.

Heat pump heating

How efficient then, can heat pumps be?

Heat pump efficiency is measured in “Heating Seasonal Performance Factor” (HSPF), which is roughly a 3.41 multiplier over how much more efficient a heat pump is.

For example, the heat pump I compared back in 2023 had a HSPF of 9.5, which corresponds to roughly 2.8x as efficient.

With that number alone, choosing the Carrier A/C unit over the heat pump was worthwhile in 2023. The Carrier A/C unit was cheaper, and using the Bosch heat pump to heat the house would have cost more than natural gas heating.

However, if we had instead purchased the most efficient heat pump on the market, that would be roughly 4.0x (13.5/3.41) as efficient.

Is that enough?

A 4.0x efficiency gain is above the 3.4x minimum bar, but that results in a monthly cost of around $176 for 120 therms. This is only a $34 savings over natural gas, which results in ~$4k of savings in 20 years.4

Unfortunately, that savings isn't enough. The less efficient Bosch unit quoted to me was $4.5k more expensive than the basic Carrier A/C unit, and the most efficient unit on the market certainly would cost much more.

Other considerations

If heat pumps are generally more expensive, why would someone ever choose to install one?

Price Projections

Over time, if natural gas is expected to be more expensive (or electricity cheaper), heat pumps begin to make more sense.

Carbon Emissions

Heat pumps generally contribute to decarbonization, because electricity is not only produced from fossil fuels. In the next decade, PSE electricity will be net zero (offsetting any emissions produced).

In my opinion, the push to decarbonization will generally raise natural gas prices, eventually making heat pumps the logical (economic) choice. However, that will only be the case if electricity costs don't also continue to rise.

Therefore, because A/C units generally last 205 years, it made the most sense to choose the A/C unit back in 2023, waiting until ~2043 to reevaluate the economic and environmental aspects again.

Flexibility

Because heat pumps are less efficient at freezing temperatures, installation will usually include a backup heat source. Having a heat pump allows for the flexibility of using electricity for whole home heating, in addition to natural gas.

Style

Lastly, choosing a heat pump is a choice. You may chose to install a heat pump because you want to, irrespective of the logical reasons behind that choice.

Being able to make a choice is one aspect of what makes us human. This may be an expensive choice, but having an opinion and making a choice based on that opinion is, ironically, logical.6

Subscribe now

1

This electricity cost amortizes taxes and the minimum residential connection charge over our typical monthly usage.

Crucially, this is the cheapest price we pay. Any usage below 600 kWh causes taxes and fees to be more impactful, and any usage above 600 kWh is charged Tier 2 (more expensive) prices.

Why did it take me so long to swap cars?

Criteria

Utility

With my current career and group activities, I need a car to commute and for occasional weekend excursions.

For reference, public transit is nearly non-existent near my address. I'm even remote enough to be out of the Sound Transit RTA tax zone, which will be discussed more later in this post.

Commuting generally consists of three 60 mile round trip journeys every week, or roughly 9,000 miles every year.2

Occasional weekend excursions vary in length and occurrence, but I'd estimate that at 2,000 miles every year.3 Unlike commuting, these trips generally involve multiple passengers and gear, requiring sufficient seating and cargo space to perform.

More specifically, this means a minimum of four seats, with ski gear (winter) or camping equipment (summer) fitting inside the vehicle.

Aesthetics

Because vehicles are a substantial investment, I also want whatever I buy to also be something I like. What that means for me is that I want a neutral “boring car”, instead of a vehicle that makes a personal or political statement.

This preference excludes sports cars, pickup trucks, and certain brands entirely (BMW, Tesla4) from my consideration.

Simplicity

I also want any vehicle that I own to be easy to operate and maintain. Simplicity excludes more brands (Kia5, Jeep6), newer models (which are more likely to have unexpected issues), or older vehicles (which will need more extensive maintenance).

Cost

Lastly, because vehicles are expensive, I want to ensure that I am getting what I am paying for. This excludes several high-end luxury brands, but doesn't exclude more expensive vehicles with luxury trims or features.

Does cost exclude EVs?

No, although it doesn't mean paying several $thousand extra for an EV is worthwhile.

My 2009 Honda Civic costed every year:

• ~$1,250 to fuel7

• ~$700 to insure

• ~$300 in maintenance (oil, tires, service, etc.)

• ~$150 in licensing (WA tabs)

• ~$2,400/year in total

For comparison, my 2021 Nissan Leaf S Plus costs every year:

• ~$500 to fuel8

• ~$1,000 to insure

• ~$100 in maintenance (tires, service, etc.)

• ~$400 in licensing

  • EVs are charged an extra $225 yearly in WA state.

• ~$2,000/year in total

Over ten years, that adds up to roughly $4,000 in savings. However, there were relatively few EVs that were only $4,0009 more expensive than their non-EV equivalents, and even fewer now that cheaper EVs are no longer exempt from WA state’s ~10% sales tax.

If you live in the Sound Transit RTA tax zone, the 1.1% tax rate on the “depreciated” MSRP value massively penalizes expensive vehicles (which depreciate faster than the official schedule). For cheaper EVs, the difference between a $30,000 EV and a $25,000 gas car is ~$50/year in licensing fees, which is less of a concern though.

EVs also tend to have a lower resale value+depreciate faster. This generally isn't a concern for me because I plan on keeping whatever I buy long enough that its resale value will be quite small anyways.

Selection

With all that criteria in mind, the main reason I didn't swap to a newer car sooner is because I didn't need to. The Honda Civic was sufficiently efficient that it didn't make sense to replace that car prematurely.

Once I began looking at replacement cars, this criteria didn't substantially filter down the viable options (there are several affordable, four seat boring vehicles). One reason I went with the Nissan Leaf is because restricting my search to EVs substantially narrowed down the field of options, while also giving me the opportunity to test out using an EV for a longer period of time.

The only other viable EV option meeting my criteria was the Chevrolet Bolt. Other vehicles that didn't meet the cut at the time include the Tesla Model 3, Hyundai Kona, and Hyundai Ioniq 5.

Once I had decided upon either the Chevrolet Bolt or Nissan Leaf, the question became one of availability. I ended up with the Leaf because both vehicles were relatively comparable, but the Leaf was easier to purchase.

Future

What do I expect in my next car purchase?

I still expect utility, aesthetics, and simplicity. Those three values underpin my past and future decision process. However, I've learned what I like and dislike from the Leaf (and other vehicles I have driven), resulting in additional minor criteria.

A future vehicle must have:

Driving

• One-pedal driving or auto vehicle hold at stops.

• Modern safety conveniences (specifically: backup camera, cross traffic detection, blindspot indicators).

• Per-wheel TPMS sensors.

• (If an EV) At least comparable range (~250-300 miles) and a standard high-speed charging port.

HVAC

• Physical buttons for all major functions (temperature, airflow patterns, recirculation, defrosting)

• Physical vent controls.

Entertainment

• Physical volume buttons on the steering wheel.

• Wireless Apple CarPlay/Android Auto or a small enough display to conveniently mount a phone or GPS.

• AM radio support. This is necessary due to state mountain pass travel announcements using AM radio.

• FM radio support.

Cargo

• Foldable rear seats

Subscribe now

Simply put, because I think my words are worth sharing.

There are plenty of stories and advice already out in the world, but I haven’t encountered my own. A younger version of myself would have found these blog posts hopefully useful, possibly interesting, and at worst, definitely present.

That’s not to say my motivations are entirely selfless. I want to express my opinions here, even if other people disagree with them. I want to improve my writing quality. In part, these posts explain who I am and how I think, better than a bullet-point résumé1 or online profile.

What do I write about?

I write about topics interesting to me. The general focus of this blog is on “life and technology”, which covers a lot of ground. If this blog morphs to focus on one area in particular, I’ll update this post to clarify what that area is.

December 6^th, 2025 Update

Why Substack?

These blog posts currently exist in written form scattered throughout various paper notebooks. Originally, I planned on adding these posts to my personal website. However, the majority of blogs that I read are on Substack. It therefore made sense to me to upload my thoughts here instead of somewhere less discoverable.2

AI

One cannot start a new blog in 2025 without discussing AI.

These post were not written with AI or other computer assistance tools, excluding Substack and Firefox spell checking. For the most part, these posts are going to be transcriptions of my paper notebooks into digital form, with relevant data (if any), charts (as appropriate), and links (as necessary) added during that process to finalize the posts.

Because I do expect to be transcribing posts discussing AI or computer-generated charts, I will call out whenever any content is computer-generated.

For example, the following dipole antenna pattern chart was made with openEMS and graphed with matplotlib. Qwen3-Coder (specifically, qwen3-coder:30b-a3b-fp16) was used to swap the chart from Cartesian to polar projection.

Questions

If you have any questions or thoughts, feel free to leave a comment below.

Leave a comment