Programming is a subjective experience

One time, I read Zen & The Art of Motorcycle Maintenance, so I pretty much know everything anybody needs to know about philosophy. At least, I know as much as one needs to know to be able to make sweeping generalizations about such things. How do I know I’m philosophically wise enough for this? Because, how have I not made this clear enough yet, I read Zen & The Art of Motorcycle Maintenance.

With that settled, I want to explain why, for me, programming is a subjective experience. Before you try and back sass me, let me redefine some key terms, specifically subjective and objective. I do this mostly because it’s an easy way to win an argument, but also because I have, like, opinions man.

Think back to college. Remember that time when you made the mistake of talking to that particularly annoying Physics major, yes, that one, the one who needed you to understand that the Universe made Sense. He cornered you for twenty minutes, proselytizing you to switch majors (but only if you were smart enough), so that you too could experience the beauty of understanding of how the world works. He’d talk about the math behind attractive forces and friction and black holes and are you doing anything later? He wasn’t wrong mind you, he just hadn’t learned yet that vector calculus wasn’t a viable replacement for charm.

There are rules and equations and math and shit that can be used to explain how tons of things in life work. If all you give me is an atom and a perfect vacuum, I can’t do all too much to surprise you if you know about the basics of physics. The rules are the rules and, given enough dedication, all the rules for how that atom and that vacuum interact can be written out and modeled and understood piecemeal. To me, that’s objective, where you can know all the rules beforehand for a situation and use them to make accurate predictions about what will happen.

Subjective is when you don’t know all the rules beforehand, can’t know all the rules beforehand, when you can only “know it when you see it”. You can try to write down all the rules and use them to make a subjectively good piece of work but then you’ll be called formulaic and fail out of your second MFA program. There are still rules when you are subjective, there’s always an explanation for why something is subjectively bad, but there isn’t an easy way to predict when something will be subjectively good. In some ways, the threshold between subjective and objective is determined by the number of rules involved. For physics, I could simplify down all the rules onto a single sheet of paper and roll from there. For art, it’s not possible to write down enough of the rules ahead of time to figure out what’s possibly going to happen. Subjective things reflect the complexity of life and the universe and how could all that fit on one sheet of paper, I mean, really?

To bring it on home, programing is subjective because we build up all these abstractions and layer them on top of each other, preventing me from understanding everything all at once. There are so many little rules and gotchas in programming that it’s not possible to know enough to predict what a computer will do ahead of time accurately. Everyday, I write programs that break in ways that I could not and would never predict to happen. Even though I could dig in and find an explanation for every thing the program does, in total, the program is an accumulation of rules that I don’t have the brain capacity to understand all at once. I can maybe remember python’s syntax, the basics of networking, the bare bones of the ftp protocol and the task at hand. The idea of trying to remember everything about how a computer works, keeping it fresh in my mind, while also trying to do anything useful is a joke. Computer programming is subjective in that I know when I’ve broken one of the rules but I can’t tell you ahead of time what all of the rules are nor whether I’m about to break one of them.

So, what I’m trying to say is that computer programming is like painting because one time I read a bunch of essays by Paul Graham and he gets this stuff deep man.

A Selection of My Finest Bookmarks (with sparse comments)

Books! looks interesting. Add it to the stacks of books to read.

Experiences! “yeah babe I hang out at the library, the library of congress, sup”


An amazing documentary, as soon as I reopened the tab I started watching it again, be careful.

Computers! <- neat!

^ Very helpful in a sort of general, sql is awful by design way <- NEAT <- when everything around you is designed by human hands, even the most mundane element of the background has a long well documented history <- in your code, finding your bugs, watching out for your product managers’s ego <- USEFUL

Thoughts! not a good read, but still a good read, you know? speak your truths dan


A genuinely interesting read.

Politics! hmmmm Hmmm HMMMMMM .... hmmm


The New York Times!

What the ‘Times’ Got Wrong About Nail Salons FUCK THAT I largely agree with the author. Interacting with a significant fraction of the people here is like interacting with the same soul put into a thousand different bodies. It's a mundane sameness and cloistered attitudes that smothers out the interesting part of life. Feels like they all want to live out the West Wing or something.

Huh? Or, A Grep Too Far

I don’t like Unix. I’ve learned Unix the same way that I learned the layout of the dark living room at night when I was a child, through sharp, sudden and painful lessons about how the World is and in absolute fear that I’ll fuck up Something so badly that somebody else will notice. Unix is not for me and I, I am not for it. But, there aren’t any other practical options besides Unix, so here I am reading man pages for a living.

strace is the lone bridge that transports me from living in a cargo cult fear of Unix, and operating systems more generally, across to a passive aggressive tolerance of the way computers work. Julia Evan’s passion for strace and all the things it lets her see about computers work was really amazing to see and I thank her for all her shared and public excitement. She definitely made operating systems more approachable and opened doors for folks. I still don’t really like Unix but at least now I have the tools to more accurately pinpoint my criticisms.

The main thing I don’t like about Unix is the command line tools. The interfaces to interact with the command line tools simply aren’t consistent. There’s no rule to learn that will help with remembering all the flags and options, no mnemonic to help you remember how to untar something. I can only remember so many things and I’ll be damned if the weird options for some program somebody wrote two decades ago takes priority in my memory over, well, literally anything else frankly. Moreover, the tools communicate via text only and have no regard for the structure of data coming out.

Using strace has drilled home this twined disdain for Unix I have. strace lists the system calls a program makes throughout the program’s execution. It takes a bewildering number of command line flags and outputs the representation of the syscalls to stdout as strings. As I’ve grown to depend on strace more in my day to day programming, the frustration of a half dozen flags to remember and stringly typed output has gnawed at me. huh is my attempt at allaying these frustrations.  I’m tired of grepping through the output of strace and having to craft the perfect string to learn what I want to know. huh runs a program using strace with all the Right Flags, parses the strace output and stuffs all of that newly structured information into Postgres. From there it drops into a psql repl and lets you mess around with the data. Here’s an example:

vagrant@vagrant:/vagrant$  ./huh ls  dev-resources  doc  huh  huh.sql    LICENSE  project.clj  resources  src  target  test  Vagrantfile
psql (9.5.3)
Type "help" for help.

huh=# select count(*) from huh_1466374554;
(1 row)
huh=# \x
Expanded display is on.
huh=# select * from huh_1466374554 limit 1;
-[ RECORD 1 ]-+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
pid           | 8622
time          | 2016-06-19 22:15:54.053177
instruction   | 00007f627c863cf7
command       | execve
args          | ["\/bin\/ls",["ls"],["XDG_SESSION_ID=4","SHELL=\/bin\/bash","TERM=xterm-256color","SSH_CLIENT= 54529 22","SSH_TTY=\/dev\/pts\/1","USER=vagrant","LS_COLORS=rs=0:di=01;34:ln=01;36...","PATH=\/home\/vagrant\/bin:\/usr\/loca...","MAIL=\/var\/mail\/vagrant","PWD=\/vagrant","LANG=en_US","HOME=\/home\/vagrant","SHLVL=2","LANGUAGE=en_US:","LOGNAME=vagrant","SSH_CONNECTION= 54529 10...","LESSOPEN=| \/usr\/bin\/lesspipe %s","XDG_RUNTIME_DIR=\/run\/user\/900","LESSCLOSE=\/usr\/bin\/lesspipe %s %...","_=\/usr\/bin\/strace"]]
return        | "0"
return_msg    |
total_runtime | 00:00:00.000071

huh=# select distinct pid from huh_1466374554;
-[ RECORD 1 ]
pid | 8622

huh=# select command, count(*) from huh_1466374554 group by 1;
     command     | count
 open            |     9
 exited          |     1
 write           |     1
 exit_group      |     1
 brk             |     3
 access          |     7
 mprotect        |    12
 rt_sigprocmask  |     1
 rt_sigaction    |     2
 arch_prctl      |     1
 set_tid_address |     1
 getrlimit       |     1
 mmap            |    19
 fstat           |    10
 read            |     7
 munmap          |     1
 set_robust_list |     1
 close           |    11
 ioctl           |     2
 getdents        |     2
 execve          |     1
 statfs          |     2
(22 rows)

It’s built on top of instaparse and clojure, mostly because the strace output can be pretty weird. No guarantee that it covers everything that comes out of strace or that it won’t fuck up your computer if you try to use it. I’ve been developing and using huh inside of a VM via vagrant.

That’s all for now, still hating on Unix, working on ways to mitigate the bad parts.

Amish Butter

It’s been said that Boris Yeltsin realized that the USSR had failed as an economic system after visiting a supermarket in Houston and seeing how much more good, cheap food was available to the average American than their counterpart in Russia. The Americans didn’t even have to wait in lines! Yeltsin apparently just roamed around the aisles, looking at all the food and considering his life choices. Just as Yeltsin sunk into a deep despair after his shopping experience, so too have I began to reevaluate my life after being introduced to Amish Butter. All I know about Amish Butter is that it is butter that is, presumably, made by Amish people and that I can buy it at the Harris Teeter by my house. Beyond that, I don’t feel like I know much about it or food in general anymore because Amish Butter has challenged my relationship with what I eat.

I was hanging out with a foodie friend in his kitchen (natch). He pulled what looked like a wad of c4 and/or lard out of his refrigerator. He grabbed a fancy knife looking thing, one of those planar knives that’s mostly just a blade and was probably originally meant to parcel out designer drugs. After sizing up a piece of bread, he cut a quarter inch thick slice of butter that covered the entire bread slice and told me to eat it. He knew better than to say try this, because you can’t just try Amish Butter, you are compelled to finish whatever the butter is on lest you let the Amish Butter go to waste and karma sees fit to prevent you from having the fortune to eat it again. Within 24 hours, I had gone out and purchased my own hunk of Amish Butter and made most of my roommates and my dad sit down and eat toast and Amish Butter with me.

Amish Butter is perhaps the only food I’ve eaten that has immediately changed my diet. It comes in two pound hunks that are surprisingly cheap. It’s got a heft to it that demands respect. I’ve refused to use a regular butter knife when slicing it out, alternating between reaching to the back of the drawer for a small sharp knife for precision slicing and a fork when I don’t feel like wasting the time to try and find the proper utensil. It doesn’t seem right to use a regular butter knife, because Amish Butter isn’t regular butter. Amish Butter is what regular butter aspires to be, the same way little kids aspire to be the president before they understand how utterly impossible it is for them to ever achieve that dream and resign themselves to living their somewhat satisfying but ultimately average and likely mediocre lives.

After Amish Butter, I now have an urgent need to deeply understand my toaster. I have more opinions about toast now than I previously thought were possible and they are all entirely predicated on finding the right level of toastedness for my bread so it can live up to Amish Butter’s exacting standards. The trick to eating Amish Butter is to eat as much as possible without getting sick. The toast acts as a transport while also reminding me of the physical limits of how much Amish Butter I can eat in one sitting. The toast can’t be so hot as to cause severe melting but it can’t be so cold as to distract from the experience. There is a certain crunch that is needed. Lukewarm cripsy toast is best for me, though I’m sure each person will find their own path towards best experiencing Amish Butter. For some reason, I can’t simply slice as I go, it has to all be cut and prepared at the beginning of the toast session. Part of the experience is seeing exactly how much Amish Butter I am about to one sitting and soaking it all in.

This all is a long winded way of saying that I’ve become that person who sits outside on his deck with two pounds of Amish Butter, a reliable knife, four pieces of toast and a massive shit eating grin  and, if you ever chance a visit to my home, you will become just such a person as well.