This post by Matt Gemmell about designing your blog for its readers is good, and you should go read it if you haven’t already. I do, however, have some nits to pick:

1. I think he’s confusing current fashion for eternal truth when he says sidebars should be removed. Why is it better to put all your meta-info in a header or footer instead of a sidebar? I agree that info about the blog should be reduced to a minimum—and, like Matt, I’ve been pruning mine over the years—but where it goes is more a matter of taste than reader inconvenience. To me, the advantage of the sidebar is that vertical space is more precious on today’s widescreen displays. Use the vertical space for content and put the peripheral stuff on the periphery—that’s where the adjective comes from. Yes, phone displays are different, but phones know how to focus on a single column, don’t they?
2. Despite my longstanding complaint that web designers make their body font too small, I think Matt’s decision to increase his body font size is wrong, too. How about just honoring the user’s choice? Yes, most users have no idea they can change the default font size (and Safari 6 made it even harder by removing the Appearance preference pane), but you shouldn’t punish those who do.
3. He’s overly dogmatic on the matter of line length and line spacing; there are many combinations that are perfectly readable. I do like that he warns against lines that are too short—a lot of sites today have such narrow content columns it’s exhausting to scroll through to the end of the article.
4. He seems to think that any framing of the content is “cruft.” Again, this is fashion, and while it’s fine to be fashionable, this has nothing to do with readability. A few years from now, Matt will be dissatisfied with the broad expanses of white he has today.
5. While I’ve had my ups and downs with comments, I still think they’re a net positive for small blogs like mine with a polite and informed readership. I understand why writers with a big audience find comments a pain; why they can’t demonstrate a reciprocal understanding is a mystery to me.

One thing Matt said really hit home:

Consider interaction methods, too: hover doesn’t really work on touch-screens, for example.

The popup-on-hover footnotes I use here seemed really cool when I stole them from Lukas Mathis three years ago, but they’ve worn out their welcome. I still think having footnotes pop up is better than jerking the reader down to the bottom of the post and then back up again, but hover isn’t the way to trigger popups in a world of iPads. That’ll have to change.

Overall, I found Matt’s advice to be sound. I was a little surprised to see his endorsement of Twitter and (especially) Facebook links. These are generally considered douchey among the cool Mac bloggers; I look forward to reading their reactions.

I’ve kept my scripts in a ~/bin directory pretty much since I started using Linux in ’97. I’m not sure if I learned to do that from someone’s explicit advice or if I just copied the idea from someone. Either way, it’s a pretty common setup in the Unix world: you create this ~/bin directory as a personal analog of /bin, /usr/bin/, and /usr/local/bin; you modify your $PATH environment variable in .profile, .bash_profile, or .bashrc¹ to include that directory; and then any executable script saved in that directory can be run from the command line without specifying the full path to it. The advantages of saving to ~/bin instead of one of the system wide bins are

1. You don’t need superuser powers to save or modify files in ~/bin.
2. ~/bin won’t get overwritten when you do a system update.

When I moved to the Mac in 2005, I kept this same setup and it’s served me well. But there’s always been one catch. If you have two computers, your ~/bin directories won’t stay in sync unless you create some clever piece of automation to keep each directory up to date with changes in the other. I never did that. I tended to move new scripts written on one computer to the other through CD-ROMs, then USB thumb drives, and then, finally, Dropbox. I often forgot to move scripts and didn’t realize it until I needed one that only on the other computer.

If you look up at the title of this post, you know what comes next, but for some reason it took me a couple of years of using Dropbox to figure it out. While it’s conventional in the Linux/Unix world to have your ~/bin directory just below your home directory, there’s no requirement for it to be there. It can be in any subdirectory of ~. In particular, it can be in ~/Dropbox/bin, where it will automatically sync between however many machines you have attached to that account.

Even after I finally realized this was the way to go, I didn’t pull the trigger. I don’t know why. Maybe it was because I’d lived so many years with out-of-sync ~/bin directories; maybe it was because the tradition of ~/bin was so strong I was afraid to change. Whatever, today I finally copied the contents of ~/bin at work into ~/Dropbox/bin and then did the same at home (skipping over duplicates), so ~/Dropbox/bin has all of my scripts. A quick edit of my .bashrc to change

export PATH=$HOME/bin:…

to

export PATH=$HOME/Dropbox/bin:…

on both machines and the transformation was complete. I now have directories for my scripts on both computers that are automatically synced. Hooray!

In case you’re wondering, I have not deleted either ~/bin directory. There is absolutely no reason in the world for the new system to fail, which is all the more reason to keep a backup for when it does.

The tweet got a little attention, so I figured it was worth explaining.

The scene I’m talking about is when Tony Stark is in Tennessee, trying to repair his suit and learn about the first Extremis explosion. After he escapes from the fight in the bar, Tony comes across Killian’s number one henchman who, in that way comic book villains have of being way too elaborate in their plans to kill the hero, melts one leg of the town’s water tower to bring it down onto Tony.

Here he is heating up the leg (big props, by the way, for using a laced design for the column):

And here he is “pulling” it down after the leg is so hot it’s almost dripping:

Both screenshots from fxguide.com.

The problem is that the leg would have failed long before it got to that orangey yellow state. Even though it doesn’t melt until about 2500° F, steel just isn’t very strong above 1000° F.

Here are a couple of charts showing the rapid dropoff of steel’s strength and stiffness (modulus of elasticity) for temperatures above 500°—700°. They’re taken from Brockenbrough and Merritt’s Structural Steel Designer’s Handbook.

These are idealized curves for design purposes, so they’re a little on the conservative side. I have an older version of this book that had a similar chart for strength with actual data points for different structural steels.

For completeness, I’ll mention that an older water tower like the one in the movie would almost certainly be made from A36 steel.

As you can see, somewhere between 1200° and 1300°, the strength of steel is about a third of its room temperature strength. Given that the water tank in the movie was full (it wouldn’t have been interesting otherwise), losing two-thirds of its strength and a similar amount of its stiffness¹ in one leg certainly would’ve brought the tower down. It might have collapsed at an even lower temperature.

What color does steel take on a various temperatures? Here’s a handy chart from Swedish steel maker, Uddeholm:

At the temperatures needed to cause collapse, the steel would be only a dull red, not the bright orange and yellow we see in the film.

And in case you’re wondering, yes, pretty much all of the above went through my head as I watched that scene. “Bothered” may be too strong a word for my reaction, but I couldn’t help but notice it. We all have areas of specialized knowledge that get triggered when we see someone get it wrong. This is one of mine.

Why does a column collapsing at the wrong temperature tweak me more than a guy melting steel by touching it? Well, the Extremis stuff is part of the comic book universe; it’s one of the futuristic/fantastic elements that drive the story. Complaining about it would be like rejecting The Lord of the Rings because hobbits don’t really exist. The water tower, on the other hand, is part of our world and should act like it. It wasn’t designed by Tony Stark.

As I said a few days ago, the inspiration for this post—apart from the actual incident in which I avoided shooting my son—was this episode of Gabe Weatherhead and Erik Hess’s Generational podcast, in which they talked about the dangers of their respective former professions—Gabe as a research chemist and Erik as a fighter pilot. The dangers associated with being a fighter pilot are pretty obvious; those associated with being a research chemist are probably less obvious, but you can get a good sense of them from the title of the episode: “What Happened When Gabe Set Himself on Fire.”

Like chemistry labs, mechanical testing labs have their own set of dangers, most of which involve the sudden, unexpected release of strain energy. You learned about strain energy in high school physics, although your teacher probably didn’t call it that. Shortly after learning about the forces in springs and Hooke’s Law, $F = kx$ (a topic we’ve looked at here once or twice), you learned that the potential energy² stored in a spring is expressed by this formula:

The $k$ in the formula is the spring constant, which is a measure of how stiff the spring is. It’s measured in units like pounds per inch or newtons per millimeter—force per length—and is always a positive value. The $x$ is the amount, as measured in inches or millimeters or some other unit of length, the spring has stretched from its natural, unloaded length. The sign convention for $x$ is arbitrary, but it’s usually taken that positive values of $x$ represent lengthening of the spring and negative values represent shortening.

You see, then, that because $x$ is squared, the potential energy in the spring is either zero (when the spring is at its natural length) or positive. This makes sense because potential energy is defined as the ability to do work. A compressed spring is able to do just as much work as a stretched spring, so their potential energies should be the same and should have the same sign. And a spring that’s neither stretched nor compressed can’t do any work, so its potential energy should be zero. So far, so good.

The reason Hooke’s Law works on a macro scale for things like coiled springs is that a very similar sort of law works on a micro scale within the spring wire. On the micro scale, the force-displacement relationship, $F = kx$, is replaced by a similar relationship between stresses (which are like forces) and strains (which are derived from deformations). In the same way that the potential energy stored in a spring is a function of its stretch, the potential energy in any deformed body is a function of its strain. Hence the term “strain energy.”

The details I’ve glossed over in the previous paragraph would fill, and do fill, volumes. My shoulders are sore from all the hand-waving, but I’ll push on.

When it comes to the ability to do harm, not all strains are created equal. It’s only the elastic strains—those which can be reversed when the load is removed—that present a danger. If you stretch a rubber band in front of your face and let go, it’ll snap back and hit you in the nose. That won’t happen if you do the same thing with a ring of Play-Doh. In a mechanical testing lab, we’re usually applying very large forces to parts and materials that have a lot of reversable elastic strain. And when things break, whether intentionally or unintentionally, the huge strain energy that’s built up as the parts have been loaded is suddenly released and turned into kinetic energy. Lab safety is all about directing that kinetic energy to where it won’t hurt anyone.

Which brings us, finally, to my son and the screw heads. One weekend a few months ago he was helping me finish up a few tests. The tests were intended to break things, and I had barriers set up to block any pieces that might come flying out at us. And of course we were wearing goggles. The tests went smoothly and no one came close to getting hurt.

We ran into a snag while taking the equipment apart. One of the pieces of the test fixture was a pipe clamped in place by four capscrews like this one:

Source: littlemachineshop.com

A side view of the clamping arrangement looked like this, with two screws on the top and two on the bottom (you see only one in each position because its mate is behind it). The screws passed through unthreaded holes in the blue piece and screwed into threaded holes in the green piece.

I had clamped and loosened this pipe many times over the previous month of testing, and internal hex surfaces of the capscrews had rounded out. Finally, after the testing was over, the Allen wrench wouldn’t grip in the screwheads and I couldn’t loosen the clamp and remove the pipe.

So I grabbed a hacksaw, slid its blade down the gap between the blue and green pieces, and drew it back to start cutting. That’s when I noticed my son standing to the left, directly in line with the screw heads.

Let me digress at this moment of high tension³ and explain how bolts and screws work. Most people know that bolted joints⁴ require sufficient torque to do their job. Many of you have probably used a torque wrench at one time or another. But most people don’t realize that torque, in and of itself, is meaningless. Bolted joints work because of the tension in the bolts, not the torque. The purpose of applying torque to a bolt is to use the mechanical advantage of the thread (which is essentially an inclined plane wrapped around in a helix) to stretch the bolt and induce tension in it. There are, in fact, bolting systems in which a hydraulic machine stretches a bolt directly by pulling on its tail and then spins the nut up tight to maintain that stretch—no torque of any significance is ever applied.

The word “stretch” in the previous paragraph should prick up you ears. Strain energy is stored in every fully tightened bolt because that bolt has been stretched. When such a bolt breaks or is cut, that strain energy gets released somehow, often by sending the bolt head flying.

In this case, there’s even more strain energy available. The flanges on the two clamp pieces are bent under the load of the screws. When the screws are cut, they’ll straighten back out, acting as a catapult to fling the screw heads.

“You need to move around to the other side,” I said.

“Why?”

“Because when I cut through, these screws are going to shoot out like bullets, and you’re standing in the way.”

“Really?” I should mention that my son is sixteen years old and therefore assumes that I’m full of shit. But he moved anyway.

I did a suprisingly good job of cutting evenly through the two top screws, and they snapped almost simultaneously. The screw heads shot across the lab and hit a piece of plywood leaning against the opposite wall with a loud th-thunk. I was vindicated; when I had to cut another recalcitrant screw a few minutes later, he stayed well out of the line of fire.

While I was happy to have proved myself not entirely full of shit, I was annoyed at my brief lapse. I’d been careful during the test but let my guard down briefly during disassembly. I should never have even picked up the hacksaw before clearing him out of the way. Strain energy is not to be messed with.

1. The dangers of stored strain energy and how I avoided shooting my older son with the head of a screw when he helped me run some load tests a couple of months ago. This topic was inspired by the May 4 episode of the Generational podcast, in which Erik Hess and Gabe Weatherhead discussed the dangers of their former workplaces and Gabe’s propensity for setting himself on fire.
2. Thermal stresses and why Katie Floyd’s glass baking dish blew up on Mother’s Day. This one would harken back to Dan Rutter’s post on Pyrex, which I read through a link from Marco Arment.
3. The alleged design and craftsmanship in this artisanal bottle opener which Justin Blanton made the unforgivable mistake of ordering.
4. How revisiting the comic books I loved as a teen has left me disappointed in both the writing and the artwork. The one exception is the early Conan series by Roy Thomas and Barry Windsor-Smith, and that’s probably because I’ve always seen myself as a latter-day Conan—black-haired, sullen-eyed, sword in hand, a thief, a reaver, a slayer, with gigantic melancholies and gigantic mirth.

And that doesn’t include more topical posts that I’ve given up on writing because their time has passed.

So tonight I’m taking the easy way out, with a short post about the iOS Drafts app inspired by David and Katie’s recent iOS Automation episode of Mac Power Users and by the Generational episode with Greg Pierce,¹ the developer of Drafts.

Last night I asked a stupid question about Drafts on Twitter:

It was stupid because Drafts can already do what I was asking for, as several kind people told me without snickering. Here’s the Dropbox action I came up with:

In my defense, the reason I didn’t realize I could use a date tag (the thing inside the doubled square brackets) in the name of the file is the name of the option that must be chosen with it: Predefined. It just didn’t seem right to me that a file with a predefined name could have its name defined on the fly. Also, it seemed superfluous to have a Timestamp option for the file name if a timestamp could be provided through tags. Still, the ability to use tags in file names goes back to version 2.5.3—I should have known about it.

Anyway,² this action is intended to help me keep track of what I’m doing at work, what the action described at the end of this post should’ve been. The idea is to launch Drafts when I switch from one task to another, tap in (or dictate) what I’m about to start working on, and invoke this action. Each time, a pair of lines will be added to a diary file for that day, one with the timestamp and the other with the note I wrote for it. Like this:

1:14 PM
Started 200° test

1:45 PM
Ended 200° test

1:54 PM
Started 300° test

The improvement over the old system is that now I’ll have a separate file for each day, all in the same Diary folder in Dropbox. To me, this is a more natural way to organize diary entries, rather than having them all with time and date stamps in a single big file. Each day’s file will have a name like 2013-05-14.txt.

This is, in many ways, the same sort of thing Katie Floyd is doing with Day One. I like Day One, but I prefer using plain text files in case there comes a time when I want to run some script over my diary files to extract information. I have no plans to do that, but I want leave open the possibility.

Of course the real trick isn’t coming up with a Drafts action, it’s developing and maintaining the discipline to make an entry every time I switch contexts. I’m working on that.

I didn’t have to look far. The natural place for scheduled, periodic tasks to live is in your ~/Library/LaunchAgents folder. And that’s exactly where I found a couple of Launch Agent plist files from CMM2.

A quick review of the plist file shows that the scheduled scan is set to run on the 12th and 19th of the month. I installed CMM2 late last month, so it’s not surprising that today was the first day I saw the notification.

I didn’t want to delete the plist files (they might be useful later), but I did want to stop them, so I ran

launchctl unload -w ~/Library/LaunchAgents/com.macpaw.CleanMyMac2Helper.scheduledScan.plist

and

launchctl unload -w ~/Library/LaunchAgents/com.macpaw.CleanMyMac2Helper.trashWatcher.plist

from the Terminal. Running the launchctl command to look for other MacPaw processes

launchctl list | grep macpaw

showed that there was still a CMM2 Helper process running, so I opened Activity Monitor and killed it.

I suppose I could’ve edited the plist files to add a Disabled key, but I find running launchctl easier. I’m always worried that I’ll add an item at the wrong nesting level when I edit XML files.

I’m not going to rant against MacPaw for installing processes without telling me, because it’s entirely possible it did tell me and I didn’t pay attention. Either way, I shouldn’t get that unwanted notification again.

You know what I mean. You’re working in the dark and need both hands free. Where does your flashlight go? In your mouth, of course. And to keep it pointed in the right direction, you need to be able to grip it between your teeth, so a metal barrel is out of the question. For several years now, I’ve been using a Brinkmann 3-watt LED Armor Max flashlight that runs on 3 AAA batteries. It has a plastic body with a rubbery grip around the barrel that makes it very tooth-friendly. It’s nowhere near as bright as Gabe’s, but it’s always been more than bright enough for my needs.

Yes, you can buy headband-mounted flashlights, but the great thing about this Brinkman is that it works perfectly well as a regular flashlight, and under normal circumstances you won’t look like a dork using it. And while you will look like a dork when you put it in your mouth, you only need to do that when there’s no one around to hold the flashlight for you and, therefore, no one around to see how dorky you look. Self-correcting!

I didn’t set out to find a biteable flashlight. I just happened to buy a Brinkmann because it was bright, compact, and water-resistant (O-rings seal the screw-on caps at either end) and learned later how helpful it was to have a flashlight I could hold comfortably in my teeth.

First, if you download his snippet collection and double-click on the file, it’ll be imported into its own folder in TextExpander. If you already have some date snippets—and I suspect most of you do—you don’t have to worry that David’s will overwrite or get mixed in with the ones you already have.

Second, you’ll notice that most of David’s abbreviations start with x. He uses that the same way I use the semicolon: as a signal character that makes it easy to come up with meaningful abbreviations that don’t conflict with real words. By using a letter instead of a punctuation character, David can sync his snippets between his Mac and his iOS devices and not have to worry about his abbreviations requiring a trip to a secondary iOS keyboard. I’d use this except for the fact that I often use variable names that start with x,¹ and my fear of conflicts is greater than my desire for snippet harmony.

Finally, and most interestingly, David has a few snippets for inserting dates that are for some date in the future. I’ve made similar snippets, but mine have always been for a fixed number of days from today. David’s are more subtle. As you can see from the screenshot, he has snippets for things like “next Monday” and “next Friday.” TextExpander’s built-in date calculation commands can’t handle things like that, so David’s snippets use AppleScript (written by Ben Waldie).

I wrote a post about these kinds of calculations last fall, discussing both AppleScript and Python solutions. In the comments to that post, David Cross (@roguemonk) pointed out a clever use of the date command that blew me away. It manages to do these same calculations in way that’s both more compact and easier to understand at a glance. The technique relies on the use of date’s -v option.

Let’s say you want to replicate the “Next Monday” snippet shown above. The date invocation that’ll do it is

bash:
date -v +1d -v +mon +"%Y-%m-%d"

Like the AppleScript in the screenshot, this gives you the next Monday (-v +mon) after (-v +1d) today.^{2 3} The formatting of the date is done through the familiar strftime library used by lots of Unix utilities and programming languages.

To make this command work in TextExpander, you need to add the shebang line for bash and you probably want to use echo -n to suppress the linefeed that date adds to the end. Your final snippet would look like this:

bash:
#!/bin/bash
echo -n `date -v +1d -v +mon +"%Y-%m-%d"`

Next Friday would look like this:

bash:
#!/bin/bash
echo -n `date -v +1d -v +fri +"%Y-%m-%d"`

And so on. The great advantage of this approach is that the strftime format is much more flexible than what you can get out of AppleScript. Just look at the contortions poor Ben had to go through to get a simple year-month-date format. If you wanted a format like “8 May 2013,” the date specifier would be easy to change:

bash:
#!/bin/bash
echo -n `date -v +1d -v +mon +"%-d %b %Y"`

I realize that writing this post so close on the heels last week’s gentle poke at Merlin Mann makes it look like I’m taking on the role of TextExpander policeman. But if I could control my obsessions they wouldn’t be obsessions, would they?

As I mentioned a few months ago, I’m not entirely comfortable with conventional web ads on the site, but I have no problem with affiliate links. I’ve been using them in my posts for quite a while when I recommend an application or book or pen or whatever. Now they’ll be in the sidebar.

I’ll certainly be tweaking the format, but what you see now is—in broad terms, if not in detail—the way I expect it to stay: an Amazon product, a Mac application, and an iOS app. A decent-sized image of each, with a sentence or two from me explaining why I recommend it. At present, the text appears when you hover over the image via the title attribute. That was easy to implement, but isn’t a permanent solution because hovering isn’t a concept that applies to touch devices. A popup system that works just as well on mobile and the desktop will be one of my first changes.¹

At present, I expect to switch the recommendations every week or two, but we’ll see how that works out. I’m notoriously lazy² and may leave some links up for longer.

I have, of course, written a couple of scripts to make it easier to add the link code to my WordPress template. Here’s the script that generates the Amazon link:

python:
 1:  #!/usr/bin/python
 2:  
 3:  from amazonproduct import API
 4:  import sys
 5:  import re
 6:  
 7:  # Get the item's ID from the URL on the command line.
 8:  itemID = re.search(r'dp/([^/?%]+)', sys.argv[1]).group(1)
 9:  # print itemID
10:  # sys.exit()
11:  
12:  # Login.
13:  api = API('myaccesskey', 'mysecretkey', 'us', 'myassociateID')
14:  
15:  # Lookup the item.
16:  node = api.item_lookup(itemID, ResponseGroup="Images,Small")
17:  itemURL = node.Items.Item.DetailPageURL
18:  imageURL = node.Items.Item.LargeImage.URL
19:  author = node.Items.Item.ItemAttributes.Author
20:  title = node.Items.Item.ItemAttributes.Title
21:  
22:  # Print the HTML to be added to the sidebar
23:  print '''<p>
24:    <a href="{0}"><img src="{1}" alt="{2} by {3}" title="" /></a>
25:  </p>'''.format(itemURL, imageURL, title, author)

This takes the URL of an Amazon product as its command-line argument and returns the HTML link code. To use it requires an Amazon Associates account, a Product Advertising API account, and the python-amazon-product-api library.

The comments in the script pretty much tell you what’s going on. You’ll want to edit Line 8 to use your own API access and secret keys and your own Associate ID. Lines 17-20 show how deeply nested the return values are; figuring out how to extract the fields I needed was the most difficult part of this script.

The script is called this way:

amazon-sidebar-link 'http://www.amazon.com/Idiot-America-Stupidity-Became-Virtue/dp/0767926153/ref=la_B001IQXNKY_1_1?ie=UTF8&qid=1367898622&sr=1-1' | pbcopy

The URL is put in single quotes to keep the ampersands (and any other special characters) from being interpreted by the shell. I typically use my ;furl TextExpander snippet to insert the URL of the page I’m browsing so I don’t have to jump back and forth between the Terminal and the browser. Piping the output through pbcopy puts the HTML output into the clipboard, ready for pasting into the template.

A similar script uses the python-itunes library to access the iTunes Search API:

python:
 1:  #!/usr/bin/python
 2:  
 3:  import itunes
 4:  import re
 5:  import sys
 6:  
 7:  # Get the item ID from the URL on the command line.
 8:  itemID = re.search(r'/id([^/?%]+)', sys.argv[1]).group(1)
 9:  # print itemID
10:  # sys.exit()
11:  
12:  # Lookup the item.
13:  item = itunes.lookup(itemID)
14:  itemURL = item.get_url() + "&uo=4&partnerId=30&siteID=mysiteID"
15:  imageURL = item.get_artwork()['512']
16:  name = item.get_name()
17:  publisher = item.get_artist()
18:  
19:  # Print the HTML to be added to the sidebar
20:  print '''<p>
21:    <a href="{0}"><img src="{1}" alt="{2} by {3}" title="" /></a>
22:  </p>'''.format(itemURL, imageURL, name, publisher)

Here, the only things you’ll need to edit are the siteID item and (possibly) the uo and partnerID items³ in Line 14. You’ll need to be a member of Apple’s Affiliate program to get those items. This script is called exactly the same way as the Amazon script above. The argument is the URL of the itunes.apple.com web page for the product.

To help me find the right web page quickly, I use Google’s site-specific searching restriction. For example, a search on

bbedit site:itunes.apple.com

brings me immediately to the page I want. Of course, I have a TextExpander snippet that expands to site:itunes.apple.com.

It’d be nice to get the product ID number directly from iTunes or the App Store application, but I don’t know how.

You’ll notice that in each script, I leave the title attribute of the <img> blank. That’s where I add my comment on the item after pasting the output into my blog template.

This site doesn’t get enough traffic for the earnings on affiliate links amount to much, but they should allow the site to pay for itself. Actually, only iTunes/App Store earnings come to me. Earnings from the Amazon account go to my daughter who, unlike many her age, didn’t come back to sponge off live with her parents after college. It’s not enough to pay for her coffee habit, but it helps.

I will not comment on how foolish I think it is for Merlin use abbreviations without some signaling character. I will not mention how really smart people like John Gruber and Jason Snell (semicolon men) and Brett Terpstra and Gabe Weatherhead (double comma men) design their abbreviations with signaling characters because doing so frees you from the necessity of devising unique, nonword abbreviations, a necessity that seems easy at first but turns into a pain in the ass when you have dozens of abbreviations to wrangle. No, I won’t say that because that would be churlish and discourteous to someone who’s always been very generous to me. Besides, I’ve already said it (more than once).

Instead, I’m going to suggest a possible improvement to one of Merlin’s snippets that will save countless seconds. The snippet in question is his “Better YouTube Link,” which is defined this way:

[**%filltext:name=artist% - "%filltext:name=Title%"**](http://www.youtube.com/watch?v=%clipboard) %|

You see that it requires the clipboard to be prefilled with the unique ID string of the video you want to link to. Which means you have to select the ID from the address field of your browser and then copy it to the clipboard before switching back to wherever you’re typing to invoke the snippet. Wouldn’t it be nicer if TextExpander could just extract that ID from your browser on its own? That’s the improvement I have in mind.

What’s needed is another snippet, an AppleScript snippet that extracts the ID from the URL of the frontmost tab of your frontmost browser window. If you use Safari, that snippet would look like this:

applescript:
tell application "Safari" to set ytURL to URL of front document
do shell script ("perl -e 'if ($ARGV[0]=~/[?&]v=([^&]+)/){print $1}' " & ytURL)

And if your browser is Chrome, it would look like this:

applescript:
tell application "Google Chrome"
  set frontIndex to active tab index of front window
  set ytURL to URL of tab frontIndex of front window
end tell
do shell script ("perl -e 'if ($ARGV[0]=~/[?&]v=([^&]+)/){print $1}' " & ytURL)

If you sometimes use Safari and sometimes use Chrome, you could use this:

applescript:
tell application "System Events"
  set numSafari to count (every process whose name is "Safari")
  set numChrome to count (every process whose name is "Google Chrome")
end tell

if numSafari > 0 then
  tell application "Safari" to set ytURL to URL of front document
else
  if numChrome > 0 then
    tell application "Google Chrome"
      set frontIndex to active tab index of front window
      set ytURL to URL of tab frontIndex of front window
    end tell

  end if
end if


do shell script ("perl -e 'if ($ARGV[0]=~/[?&]v=([^&]+)/){print $1}' " & ytURL)

If you have both Safari and Chrome running at the same time, this one will try to get the ID from the frontmost tab of Safari. This may not be what you want, but I don’t know how to make the script read your mind.

Anyway, give that snippet a good abbreviation, like ;ytid, and then define a new snippet that’s very much like Merlin’s:

[**%filltext:name=name:default=Artist% - "%filltext:name=Title%"**](http://www.youtube.com/watch?v=%snippet:;ytid%) %|

Notice that this one uses the ;ytid snippet instead of the clipboard to fill in the video ID string. TextExpander’s ability to call one snippet from within another allows you to use snippets like subroutines.

Obviously, I’m assuming that the most common situation in which you’d use the Better YouTube Link snippet is when you have the video in the frontmost tab and you want to create a Markdown link to it in your text editor. If that’s not the case—if, for example, you usually want to create the link in a text entry field in another browser tab—then this won’t be an improvement for you. Stick with Merlin’s original. (But change the abbreviation to start with a semicolon.)

PCalc added an f(x) key in Version 2.6 as a way to access functions beyond those available on the keys. Initially, the additional functions were limited to whatever the developer, James Thomson, gave us. Here’s me, back in December:

What I’d really like to see, though, is an expansion of these functions. Things like present value, future value, and internal rate of return are natural for the financial section. And the statistical section could use functions for the normal and inverse normal cumulative distribution.

This was not based on any insider knowledge. High-end calculators have been programmable since the 70s, so it was only natural to expect that functionality to come to PCalc eventually. We just had to wait for James to figure out how he wanted to implement it.²

In this post, I’m going to focus on creating user-defined functions. The creation of user-defined conversions follows almost exactly the same steps and has access to the same set of commands—once you’ve learned how to define functions, you’ll have no trouble defining conversions.

Creating a new function

Start by tapping the f(x) key to see the list of function categories and then tap the Edit key in the lower left corner. You’ll get a ⊞ key in the upper right corner, which will allow you to add new categories. As you can see below, I’ve added three categories: Financial 2, Probability, and Weather.

Tapping the ⊞ key on this screen will create a new category. Tapping that category takes you to a screen where you can rename it and then start defining new functions.

Tapping the new function takes you to a screen where you can rename and define it. PCalc starts you off with two commands: one that puts you in decimal mode (if you weren’t already there) and one that multiplies the current value by the universal constant.

You can change these by tapping them, which will take you to a command editing screen we’ll discuss in a bit, and add new commands by tapping the ⊞ key.

The command set

PCalc gives you 39 commands from which to build your function. Here they are, with descriptions, as they appear in the scrolling list you see as you construct your function.

Seven of the commands have only one part—the command itself with no arguments. These are typically commands that set the calculation mode, like the Decimal Mode command we saw above or the Radians Mode command.

Seventeen of the commands have two parts, in which you have to choose both the command itself and a single argument. The trig, log, and exponential commands work this way, as does the Clear command.

We’ll discuss how to set the argument in a bit.

Nine of the commands have three parts: the command and two arguments. The basic arithmetic commands (My Dear Aunt Sally) fall into this category, as does the command that sets a register.

Finally, six of the commands have four parts: the command and three arguments. These are all branching commands that test one value against another and skip a given number of steps if the test is true.

Variables and constants

Numerical functions need places where they can store numbers and retrieve them from. PCalc provides 29 such places: the X and Y registers, ten memory locations, sixteen registers, and a special register called Tax Rate used in some of the builtin financial functions. In addition to these read/write variables, there are three read-only constants: Pi (π), a uniformly distributed random number between 0 and 1,³ and a user-defined constant called Value.

Here’s PCalc’s scrolling list of variables and constants you can choose from. If you’re setting or changing a value, the constants don’t appear in the list.

The X and Y registers and the memory locations are accessible any time you’re using PCalc. Registers 0-9, A-F, and the Tax Rate are accessible only through the programming environment; they’re the best place to store intermediate results because they don’t alter what the user has stored in memory.

At present, PCalc does not clear these registers after a function is calculated. The Tax Rate register will certainly stay this way, but I don’t know if that’s true about the others, so you’re taking a bit of a risk if you write functions that rely on their persistence.

Update: James says the persistence of the registers is part of the design, so it’s safe to take advantage of that if you want.

A simple example

Let’s look at a five-step function for calculating the future value of an investment. The formula is elementary:

where $FV$ is the future value, $PV$ is the present value, $i$ is the interest rate per compounding period, and $n$ is the number of compounding periods.

The function I defined calculates just the $(1 + i)^n$ part. It gives, in effect, the multiplier associated with the compounding. Here’s the function defined in PCalc:

It expects the interest rate in the Y register and the number of compounding periods in the X register; it returns the future value multiplier in the X register. To run this function in RPN mode, which is what I use, you type in the interest rate, tap Enter, type in the number of compounding periods, and then select the Future Value function from under the f(x) key. In algebraic mode, you type in the interest rate, tap the x~y key, type the number of compounding periods, and then select the Future Value function from under the f(x) key. It’s the same amount of work either way.

James has decided that functions that need more than two arguments will have to use the memory locations for the extra arguments. I’d much prefer to be able to load up the RPN stack with all my arguments (it’s faster than entering values into memory), but that would leave the algebraic users out in the cold.

Sharing functions

You can share the functions you write with others by tapping the share button and sending an email with the functions bundled up in an attachment. When the recipient gets the email, she can tap on the attachment and choose to import them into her copy of PCalc.

It’s my understanding that functions you define on one iOS device will be automatically available on your other iOS devices through iCloud syncing. With only an iPhone, I have no way of testing this.

Programming on your computer

For functions with only a few steps, the tap-scroll-tap method of creating functions on an iPhone or iPad is just fine. But for more complicated functions, it’s easy to get lost and make mistakes. Fortunately, there’s a way to program PCalc in your favorite text editor.

When you send an email with a shared bundle of functions, the attachment is a plist file with a .pcalcfunctions extension. If you save this file to your computer, you can open it in a text editor to see the usual plist structure. Each function is a <dict>, with its code stored in a string using a compact little language. Here’s definition of the Future Value function described above:

xml:
<key>function.user.579085775.3922504026</key>
<dict>
  <key>Code</key>
  <string>set r0 1; add r0 y; pwr r0 x; clr y; set x r0</string>
  <key>Name</key>
  <string>Future Value</string>
</dict>

If we rearrange the string of code, it’s easy to see how it relates to our definition above.

set r0 1
add r0 y
pwr r0 x
clr y
set x r0

This shows us the path to writing long, complicated functions:

1. Create a new function in PCalc. Give it the name you want and put it in the category you want, but don’t bother changing the definition from the two-command default we saw near the top of the post.
2. Share that function with yourself via email. Open the email on your computer and save the attached .pcalcfunctions file to disk.
3. Write the function you really want in the little language used in the ,pcalcfunctions plist. I write mine with each command on its own line and then do a search-and-replace to turn it into a long, semicolon separated string.
4. Replace the default commands in the .pcalcfunctions file with what you just wrote.
5. Send yourself an email with the edited .pcalcfunctions file attached.
6. Open that attachment on your iOS device to install the redefined function. It’ll replace the old definition.

This may seem like too many steps, but it’s much easier than writing a long function directly in PCalc.

One of the functions I wanted is the cumulative distribution function for the standard normal. There is one of those integrals that can’t be performed analytically, so it has to be approximated. Here’s a good approximation from Abramowitz and Stegun:

And here’s that formula (generalized to handle negative arguments) converted into a PCalc function:

set r0 x
bgt x 0 1
  neg r0
set r1 r0
mul r1 .2316419
add r1 1
inv r1
set r2 r1
mul r2 .319381530
set r3 r1
pwr r3 2
mul r3 -.356563782
add r2 r3
set r3 r1
pwr r3 3
mul r3 1.781477937
add r2 r3
set r3 r1
pwr r3 4
mul r3 -1.821255978
add r2 r3
set r3 r1
pwr r3 5
mul r3 1.330274429
add r2 r3
pwr r0 2
div r0 2
neg r0
exp r0
set r3 2
mul r3 pi
pwr r3 .5
div r0 r3
mul r0 r2
blt x 0 3
  set x 1
  sub x r0
  stp
set x r0

It’s much faster to type the lines than to scroll through the list choosing commands and registers, and it’s easier to see the overall logic this way.

All the command abbreviations

The main difficulty in writing PCalc functions in a text editor is figuring out what the abbreviations are for each of the commands. To help with this, I created, in PCalc, a fake function with 37 steps—one for each of the commands. After sharing this function and opening the .pcalcfunctions file on my computer, I extracted all the commands. Here they are with their default arguments and an explanatory comment:

set x 42      # Set X to 42
clr x         # Clear X
add x 42      # Add 42 to X
sub x 42      # Subtract 42 from X
mul x 42      # Multiply X by 42
div x 42      # Divide X by 42
neg x         # Negate X
inv x         # Invert X
pwr x 42      # Raise X to the power of 42
roo x 42      # Raise X to the power of 1/42
sin x         # Sine of X
cos x         # Cosine of X
tan x         # Tangent of X
asn x         # Arcsine of X
acs x         # Arccosine of X
atn x         # Arctangent of X
ln x          # Natural log of X
log x         # Base 10 log of X
exp x         # e to the power of X
e10 x         # 10 to the power of X
fac x         # Factorial of X
rnd x         # Round X to nearest integer
trn x         # Truncate X to nearest integer
hyp x 42      # Hypotenuse of triangle with legs X and 42
leg x 42      # Leg of triangle with hypotenuse and other leg of X and 42 
dec           # Decimal mode
hex           # Hex mode
oct           # Octal mode
bin           # Binary mode
deg           # Degrees mode
rad           # Radians mode
jmp 1         # Skip 1 step
beq x 42 1    # Skip 1 step if X is equal to 42
bne x 42 1    # Skip 1 step if X is not equal to 42
bgt x 42 1    # Skip 1 step if X is greater than 42
bge x 42 1    # Skip 1 step if X is greater than or equal to 42
blt x 42 1    # Skip 1 step if X is less than 42
ble x 42 1    # Skip 1 step if X is less than or equal to 42
stp           # Stop

These are in the same order as the screenshot list. Most of the names are immediately obvious; others take a little thinking to understand. The inverse power command, roo, is short for root.⁴ The b at the front of beq and the other skip commands is short for branch. The only one I’ve had trouble remembering is pwr, which I tend to type as pow.

Finally

A calculator isn’t necessarily the best tool for complicated analyses, but sometimes it’s the best tool that’s readily available. Because PCalc is in my phone, its capabilities—whatever they are—are always with me. The addition of user-defined functions allows me to do calculations away from my desk that I couldn’t do before.

This post wasn’t intended to be a breezy read. Its main purpose is to act as a reference to help you (and me) get new functions written. I don’t know if James intends to host a repository of functions at pcalc.com, but I’ll be putting all my functions in this GitHub repository. At present, it has three sets of functions:

• Financial 2.pcalcfunctions. This has the future value function shown above, a present value function, and a loan payment function.
• Probability.pcalcfunctions. This has the standard normal PDF, CDF, and inverse CDF.
• Weather.pcalcfunctions. This has functions for calculating the wind chill factor and the heat index.

The README is pretty rudimentary at the moment, but it does explain the inputs and outputs of each function. I’ll be adding better explanations of the underlying calculations soon.