One Day Build – Life Expectancy Comparison a la SQL and Python

I was inspired today to continue learning. Thanks to some folks over at Penny University (, I found a quick little learning opportunity. I am focused this month on learning some more skills in SQL and in JS. A list and map of life expectancy data was posted to our slack channel ( and showed some very interesting level of detail. County and census track level analysis had been done for the first time ( and this paper indicated that life expectancy varies at an even smaller, very local scale in the US. So, that was a neat read. But I noticed two of the tables in the wikipedia article, one that shows the break down of these numbers by state and another by the 50 largest US cities. I had a guess that the largest population centers in the US had a large effect on the data of the states in which they are located. This looked like an opportunity to try to do two things:

  1. Get a statistic for how similar the city data and the state data are for states where the 50 largest cities are located.
  2. Plot the same in python and hopefully get the same answer.

Half of this build was spent just cleaning up 5 data sets I grabbed related to this idea, 3 from the wikipedia and 2 from the CDC. I’ll probably keep playing with this so it was neat to try taking 5 .csv files and dumping them into a MySQL database. I got to remind myself how to regex find and replace with back references in gedit and that was kinda terrible, but with the datasets cleaned up sufficiently I could make a script for building the tables in a new database (No really, this took a while). I learned today about mysqlimport and the use of –local and I learned another way via ‘LOAD DATA INFILE’. I learned the use of ‘FIELDS TERMINATED BY’ because some of my files were tab separated and some were comma separated.

My first gotcha came when I learned about DECIMAL declarations for the numerical fields I wanted to import. DECIMAL is really an integer by default and that’s weird to me. The default is to give you a rounded value until you tell it specifically how many digits there are in total and how many come after the decimal point. 

Then there was some more back and forth deleting and loading the data while checking on the warning messages. This was pretty straightforward. 

Then I had to come up with the interestingly complicated SQL call below:

select avg(d) as avgd from (select avg(s.LE2018)-avg(c.LE2018) as d
 from LEByState1018 s join LEByCity c on s.State=c.State group by s.State) t;
| avgd |
| 0.037269585161 |
1 row in set (0.01 sec) 

I want to have the states that are in common between the two tables. I do that by from table1 alias1 join table2 alias2 on condition , then I can take the average on the grouping of states. The trickiest part for me was realizing I needed to have avg(s.LE2018) because in this table each of these only had one entry. But, there was a check against these entries being not aggregated in the group. Then I have to make sure to name everything and it works. I have my answer: 0.037 years or 13.5 days is the amount by which large cities differ from their states’ average on average.

But what is the breakdown? I want to see this stuff plotted. So I will see what I can do in python. There was a lovely post from With the MySQLdb library and pandas I was able to drop my SQL tables into some dataframes with 4 lines of code easily implemented with no surprises.Comparison of States and Cities for LE

Comparison of 2018 Data for States and 50 largest US Cities for Life Expectancy. copied 10-8-2020


I made some plots and could see that indeed in many cases there is a close correlation. The abscissa doesn’t mean a whole lot but you can see the main point. Everything trends pretty close to the mean +- about a year and a half. The obvious point of note is Virginia Beach having a six year lower life expectancy than Virginia as a whole. My guess is there is a skew towards DC. But who knows. If I decide to go deeper on this I might try to recreate the data from the PNAS paper for a next little challenge. 

Things that ‘shouldn’t’ work

Virtual learning is a challenge for all this year. My wife is a teacher and is struggling in that boat. She encountered a scenario which was very frustrating for her and reminded me of a very important and often over looked point of problem solving. 

She was on the phone with administrators and technical support for her virtual learning platform for several hours, because she couldn’t login. They tried password resets, support staff tried to reproduce the error on a different computer and couldn’t (they were successful), but my wife was not successful on a different computer and others were successful on her computer. All to no avail. After trying many things, in the end, the third tier technical support professional tried to give her a new username. He said, “this shouldn’t work” but let’s just try it. Lo and behold, it worked. A spelling error in the database for her email (as a username) had led to her not being able to login, because she had been using her email spelled correctly. The company and others trying to help, had been copying her misspelled username from the database and it was working for them. Frustrating, to say the least, that many had not double checked the spelling of “schoos” instead of “schools” in the email. 

The idea that I want to promote here is not the Sherlock Holmes quote “When you have eliminated the impossible, whatever remains, however improbable, must be the truth.” This quote shows up in at least six books of Doyle’s. I am also not promoting the idea of trying to break the things that you have made, in order to test them. Although, this is also a very good idea. I am also not saying do nothing but question what has already been well established. If we do that, we never progress. 

No, rather I want to promote the idea of perpetual self-reproach and self-questioning. In order to be a good problem solver, one should have a practice of trying things that shouldn’t work. One should try the things that you know in advance should fail, because HOW they fail is so very important. 

This is fundamental to nuclear physics, where we learn so much about nature from watching things decay and from watching things explode and collide and reveal constituent components. It is vital in life, to ask myself, “What are my preconceived notions?” or “Have I been rude or prejudiced today?” or “Is there anything that I can do today to be more considerate of the people around me?” 

I find my faith life helps me here. I have a spiritual practice of knowing I am redeemed in my life. That I am capable of doing some good, because there is one who is good that lives for me and in me. I know that “all have sinned”, but that I am “free from condemnation” to use some quotes from Romans. So, I can approach myself continually, loving being wrong. I can confidently ask myself, “Am I evil?”, I can answer, “Yeah, probably.” Then I can take a deep breath, recognize the very spirit of God in every breath and heart beat, and I can be better today than I was yesterday without being crippled by shame.

I can learn. I learned today that it may not unfortunate that style often wins over substance (this thanks to MC in a learning community that I’m a part of called Penny University ( Maybe style is simply a vital part of substance. 

The point is this, I shouldn’t wait to prove all the other things impossible before I consider the improbable. I should build a life where I question myself and my most cherished ideas. I’m convinced that taking old and well practiced ideas and converting them to new and better ones is the hardest thing anyone can ever do. When it happens though, it is a revolution and new ideas have the power to solve all kinds of problems. 

Be well, Stay safe


The wonder of invisible things

Today I will write about one of many aspects of learning and problem solving in general that I’m very passionate about. 

Invisible things make the world go round. I don’t just mean that the basic building blocks of our universe are invisible. As a physicist, you can assume I also mean that. But there is a kind of aspect to problem solving that invokes something that isn’t just unseen by the naked eye, it is truly fiction. I’m talking about the cases like dropping a perpendicular line in geometry. In any given geometry problem, there are an infinite number of lines you can draw and most of them are decidedly unhelpful. However, a particular choice ( usually a perpendicular line) that comes with a constraint unlock the next step and allows you to say something new about the system. An iterative process of this kind, bootstraps knowledge together in such a way as to unlock problem solving. This is wondrous to me. 

It doesn’t stop there. Physics is rife with such problems to solve. The brachistochrone problem was one of many like this for me in graduate school. Problem solving in this system was unlocked by a particular set of co-ordinate choice. For other problems the key was the ‘right’ choice of basis in a quantum mechanics course. The ‘right’ one was of course revealed by the choice making the problem tractable at all. The common frustration between myself and my peers was ‘how do you know in advance what to choose?’ The response was a disappointing, ‘you can’t always know.’ Progress is made by an arbitrary choice of something abstract, something fictional or something invisible. 

More recently, I found this with a counting problem. I wanted to index the difference of the elements of a vector with itself so position 0 minus position (1,2,3, … ) then the difference of position 1 with position (2,3, … ) pretty easy to set up two loops over these indices. In python:

for i in range(0,maxi-1):
    for j in range(i+1,maxi):

With maxi being the total length of the vector of interest. This makes something like traversing an upper left triangular matrix. Well then I wanted a counter in this loop that goes (0,1,2,3,4….). It didn’t take too long for me to realize triangular numbers (n(n+1)/2) and indexing were involved but the specific form was a little illusive.

I started from what I could see (the elements of the vector) and I started counting from the bottom up of a smaller upper left triangular table. I reasoned that if I could count 1,2,3 from the bottom up, simple subtraction for the max value counts me down. I used a good problem solving step as well, I reduced my issue to something smaller but equivalent and worked on a whiteboard instead of the larger vectors I was interested in.  I got to the end, redid it because I made some mistakes and back substituted some new variables I had created and I realized that the final form indicated a much simpler derivation than all the steps I had taken to get there.

Had I, from the beginning, imagined a square matrix with indices i,j (row,column) and imagined subtracting off the ends of the lines I could have almost just written down j+i*maxi - 1/2(i+1)(i+2). Where the term, j+i*maxi counts through a square and 1/2(i+1)(i+2) is a triangular number index but for the bottom-right triangular array that is then subtracted off. But in truth, that part doesn’t exist. It is invisible. It is fictional and it absolutely unlocks the solution to the problem at hand.

It is incredible to me that I have made a career out of solving problems by looking at invisible things. 

Be well, stay safe


Next: Trying solutions that “shouldn’t” work

One day build – Scheduler

If have to do anything more than twice, I’m likely to make a script to help. 

Like so many others we are keeping to ourselves these days and it was helpful to make a scheduler pop-up for telling me when to move my child onto the next task during the day. Enter my super easy one day build. 

The relevant library was notify2 in python.  It tells my OS to pop-up a notification and send me a message.

import notify2
from playsound import playsound as ps
import schedule
import time

Then I set the important variables and initialize the relevant objects. These are a Notification object and a sound file name string. 

n = notify2.Notification(None)
song_file = "gw151226.mp3" 

It plays a gravitational wave chirp. Quite nice. Then, I define one of several ‘jobs’.

def job1():

where ps is playsound.playsound() from the import line. It is then invoked with some variant of the ‘schedule’ program. 


And that’s all there is. 

Be well, stay safe, wear a mask. 



On the Date of State Of The Union

As I sat at lunch today, I noticed that the state of the Union is tonight. I thought, ‘Wow! That’s late isn’t it?’ But I wasn’t sure.

So, I did the math. Here is the result:

If we look back to the dates from 1910, the current date is 1.3σ away from that mean. Furthermore, presently (since 1980), the later dates with smaller variance are still only 1.5σ away from the mean. If these fluctuations were random, 3σ would be within expectations. The σ of 6 for this time period is exactly what you would expect for random fluctuation about some average.

The only interesting thing I noticed was that the ~1940 lower average seemed to transition between 1960-1980 to a new later average.

Does anyone know of a reason why?

One Day Build (House Hunting)

We’re in the middle of house hunting in Nashville (which is booming).

So, I wanted a tool that would help me vet addresses as they pop-up in my feed from our realtor.
We wanted to be able to walk to some things in our neighborhood and fortunately that criterion a pretty easy thing to map out by hand in inkscape with screenshots from Google maps. I was able to produce a png map that had those regions clearly identified. For those that remember the 2010 floods, water ways are something to be wary of. So I pulled a map from FEMA ( and overlayed that with a transparency by hand, easy enough. I could also have tried to overlay crime maps and offender registries, but this was sufficient for triage.

Now I just needed a converter(mapper) between the x,y in inkscape and gps coordinates.
I used PIL (python image library, aka pillow) to draw on the picture I had created.
The converter looks like this:

def mapper(lat,long):
#scale = [4528.104575164487, -162821.9551111503, 3633.747495444875, 315924.9870280141]
#return(long*scale[2]+scale[3],flip-( lat*scale[0]+scale[1]))
scale = [-5228.758169935899, 189234.5555556009, 4041.34431458903, 351362.65809204464]

There are two attempts here because a conversion from GPS coordinates to inkscape coordinates is unfortunately not the same as GPS to pillow.

I derived this via two “calibration” points on my map and the respective coordinates in pillow.

given = [[36.039065, -86.782672],[36.042890, -86.606493]]
res = [[644, 795],[1356,775]]
a = (given[1][0] - given[0][0]) / (res[1][1] - res[0][1])
b = -a * res[0][1] + given[0][0]
c = (given[1][1] - given[0][1]) / (res[1][0] - res[0][0])
d = -c * res[0][0] + given[0][1]
scale = [1/a, -b/a, 1/c, -d/c]

This finds slope and offset for two categories , latitude and longitude, based off of four points and is exact (those potentially off by a little depending on the accuracy of my calibration points). I should’ve picked points better, because 36.039 is not very different from 36.042. Oh well. In the end it worked.
Then I just hardcoded the values of the variable scale into the function mapper.

I have my x,y coordinates from latitude and longitude. Now I want to draw on my map.

def drawer(coords):
im ="pillow.png")
draw = ImageDraw.ImageDraw(im)
flip = im.size[-1]
for pair in coords:
vec = [mapper(pair[0]+0.001,pair[1]-0.001,flip),

It makes all the points the same color which makes it difficult to judge multiple new points on a figure, but this was sufficient for my purposes.
The plus and minus 0.001 was found by trial and error to make the correct sized dots on the map.

The tool was just for me but my wife also appreciated that we could use this to quickly go through the initial barrage of home listings
and weed out the listings that were for sure not going to be of interest.

Not too bad for a few hours of work and most of that was just deciding and drawing out the regions of interest.

Machine Learning for Scientific Applications

Data taken in scientific context often forms an image. Whether this is a reconstruction of a physical space or if it is simply a graphical representation of data, machine learning and image processing tachniques can have some use for a scientist.

In one context, energy sharing between two detectors forms lines of a constant sum.

In this case it was not possible to calibrate the y-axis directly. Only the x-axis and the sum could be accurately calibrated. Instead of recursively scanning and re-calibrating the data, one can use a clustering algorithm called k-lines means. The slope of these lines is the negative reciprocal of the slope of the calibration. 

In this case, rapid convergence even for k=3, fewer than the k=9 which is closer to the number of calibration points which is physically meaningful.

This fact allowed for a fast running algorithm which can run online for stability monitoring.