Brett’s links work because the NVs are registered to respond to the nv:// URL scheme. Similarly, the Address Book is registered to respond to addressbook:// URLs. A full URL to a particular contact in your Address Book will look something like this:

addressbook://68A46B71-150A-4732-A183-D99EECCE1F18:ABPerson

That happens to be the URL to the Apple, Inc. entry in my Address Book.

I’ve written about this a couple of times, and have incorporated links to contacts in PNotes, the no-server personal wiki I use to keep track of project notes at work.

The portion of the Address Book URL after the double slashes can’t, as far as I know, be extracted directly from Address Book itself, but it is accessible via AppleScript. Here’s a simple script to get the URL for a selected contact and put it on the clipboard.

1:  tell application "Address Book"
2:    set ABURLs to ""
3:    set contacts to the selection
4:    repeat with thisPerson in contacts
5:      set ABURLs to ABURLs & ("addressbook://" & id of thisPerson) & return
6:    end repeat
7:  end tell
8:  set the clipboard to characters 1 thru -2 of ABURLs as text

If you have several contacts selected, it will return URLs to all of them, one per line.

The key to the script is Line 5, where the URL is constructed from the id property of the current contact. When the repeat loop is finished, there’s a trailing newline at the end of the ABURLs string. This is stripped just before the string is put on the clipboard in Line 8.

If you think there’s something funny about this line, you’re not the only one. As you can see, AppleScript, like many languages, can count back from the end of a string by using a negative number. The -2 in Line 8 refers to the “second to last” character in the string; -1 would refer to the last character. What I find odd about this is that other languages that use negative string indices—Perl, Python, and Ruby, for example—treat the index as an offset, with positive numbers (and zero) as offsets from the beginning of the string and negative numbers as offsets from the end. AppleScript, though, doesn’t use offsets in the forward direction; the first character in a string is character 1, not character 0. Why does it use offsets in the backward direction?

(Am I overthinking this? No doubt. I’m sure AppleScript’s designers would argue that you count characters the same way forward and backward but use negatives when counting backward. Still, if you’re used to the way character offsets work in other languages, AppleScript’s indexing seems inconsistent.)

Another thing that may strike you as weird is the as text at the end of Line 8. Isn’t ABURLs already text? Yes, it is, but

characters 1 thru -2 of ABURLs

is a list. The as text is necessary to turn that list back into text.

So, once you have an Address Book URL, what can you do with it?¹ In local web pages, like PNotes, you can link someone’s name to the corresponding Address Book entry:

<a href="addressbook://68A46B71-150A-4732-A183-D99EECCE1F18:ABPerson">Apple</a>

In scripts, you can use Apple’s open command to do the same thing:

open addressbook://68A46B71-150A-4732-A183-D99EECCE1F18:ABPerson

Unfortunately, OmniOutliner, an otherwise lovely program, doesn’t recognize Address Book URLs, so unlike http:// links, strings that start with addressbook:// don’t get automatically turned into clickable links. That’s something the OmniGroup could improve on.

Another unfortunate thing about Address Book URLs is that they don’t seem to be consistent across computers, even with iCloud syncing. The link I gave above for the Apple entry in my Address Book works only on my MacBook Air. On my iMac, that same entry has this link:

addressbook://313FB5BC-F075-48F2-8BE1-BBC1F31FD374:ABPerson

I assume the difference has something to do with the algorithm Address Book uses to generate an entry’s id. Maybe the id isn’t part of the package of data that gets synced, but is created on the fly as the entry is imported. Whatever the reason, it would be nice if the links were consistent across my computers.

Before we let it go, though, I think it’s worth reflecting on these totals for Iraq:

• US military deaths: 4484
• Coalition military deaths: 4802
• Weapons of mass destruction: 0
• Connections with September 11 terrorists: 0
• Threats posed to US and her allies: 0

As for Afghanistan, a war that was easy to justify in 2001 but not today, January had an uptick in military deaths.

With luck, we won’t see the big increases that have occurred every spring for the last three years.

Übergeek? Really? I mean, I really like that script because it uses PDFpen to turn a tedious, 2-3 minute task into a one-step, 2-3 second task, but there isn’t much to it. The trickiest part was getting the syntax right for adding text to a PDF. How did I work that out? As I said, I stole it from this script,

 1:  -- This script allows the user to enter text to imprint on all pages.
 2:  
 3:  tell application "PDFpenPro"
 4:    if (count documents) > 0 then
 5:      set dialogResult to display dialog "Enter text:" default answer "Draft"
 6:      if button returned of dialogResult is not null then
 7:        set theText to text returned of dialogResult
 8:        tell document 1
 9:          set imprintCount to 0
10:          set pageCount to count pages
11:          repeat with aPage in pages
12:            set theImprint to make new text imprint with properties {rich text:theText} at end of imprints of aPage
13:            set font of attribute run 1 of rich text of theImprint to "LucidaGrande-Bold"
14:            set size of attribute run 1 of rich text of theImprint to 30
15:            set color of theImprint to {1, 0, 0}
16:          end repeat
17:          return pageCount
18:        end tell
19:      end if
20:    end if
21:  end tell

which should look familiar to Jean. It’s called “Imprint All Pages With Text,” and it’s provided by Smile Software as an example of the kinds of thing you can do with PDFpen and PDFpenPro. See any resemblance between Lines 12-15 of that script and Lines 11-14 of mine?

11:    set stamp to make new text imprint with properties {rich text:dstamp, x position:410, y position:262, width:144, height:16} at end of imprints of page 1 of document 1
12:    set font of attribute run 1 of rich text of stamp to "Helvetica"
13:    set size of attribute run 1 of rich text of stamp to 12
14:    set color of attribute run 1 of rich text of stamp to {0, 0, 0}

I would never have been able to write my script without the example provided by Smile. I knew from PDFpenPro’s AppleScript dictionary that it had something called text imprints and that they had a rich text property, but I had no idea how to set and style the rich text until I saw the sample code.

By the way, this illustrates an important point. There are only two ways to write AppleScript code:

1. Copy someone else’s and adapt it.
2. Keep trying different syntax until something works.

Most of the time I have to use both approaches. Is it any wonder I hate AppleScript? I’ve been programming in it since the mid-90s and I still feel like a novice.

So anyway, there was nothing übergeeky about that script. No clever algorithms, no brilliant insight. I just had an idea for saving time, and I hammered away at the script until it worked.

Which isn’t to say I can’t be übergeeky in my real area of expertise. I’ve written several posts like that. And when I finally get around to writing my long-delayed post on 19th-century suspension bridges, fluxions, and the tenacity of iron—hinted at in this interview over at MacDrifter—the geekiness will be über indeed.

The AppleScript automates the chore of filling out W-9 forms. This is the IRS form in which you certify that you’re not subject to backup withholding. Our clients don’t want to deduct backup withholding from their payments to us (and we certainly don’t want that, either), and having this form on file justifies their not doing so. I’m convinced it’s a waste of time and effort, but if it makes them happy I’ll fill out the damned form.

Actually, from today forward, I won’t be filling out the W-9s—AppleScript and PDFpenPro will. All I’ll be doing is running the AppleScript and emailing the filled-out form to the client. Here’s how I’ve set things up.

First, I downloaded a PDF of the form from the IRS and opened it in PDFpenPro.² It’s a four-page document, but three of the pages are instruction, so I deleted them from the document. Most of the form fields that need to be filled in—the company name, address, and EIN—never change, so I did that, leaving me with a document that looks like this:

This will be my base document, a template for all the customized W-9s I’ll be producing. I keep the template in my Dropbox folder so I can access it from either of my computers.

The only field that needs to be customized is the date next to my signature.³ That’s filled out by this AppleScript:

 1:  set today to current date
 2:  set dstamp to (month of today as text) & " " & (day of today as text) & ", " & (year of today as text)
 3:  
 4:  tell application "Finder"
 5:    set w9 to document file "Test W9.pdf" of folder "Dropbox" of home as text
 6:    set neww9 to (desktop as text) & ":Test W9.pdf"
 7:  end tell
 8:  
 9:  tell application "PDFpenPro"
10:    open w9
11:    set stamp to make new text imprint with properties {rich text:dstamp, x position:410, y position:262, width:144, height:16} at end of imprints of page 1 of document 1
12:    set font of attribute run 1 of rich text of stamp to "Helvetica"
13:    set size of attribute run 1 of rich text of stamp to 12
14:    set color of attribute run 1 of rich text of stamp to {0, 0, 0}
15:    close document 1 saving in neww9
16:    quit
17:  end tell

Lines 1 and 2 get the date in the format I want to insert into the form. Lines 4-7 get the paths to the template form (in Dropbox) and the currently non-existent filled-out form (which will be on my Desktop). If you want to use this script, you’ll probably want to change the file name, if not the folders, of these paths.

Line 10 then opens the template in PDFpenPro and the fun begins. Much of what follows was taken almost directly from one of the sample AppleScripts that comes with PDFpen.

Line 11 adds the date as a “text imprint”—that’s a PDFpen-specific term for text you add to a PDF—to the template at the proper coordinates. Lines 12-14 then set the formatting for the date to black 12-point Helvetica. Any of the values in these lines can be tweaked to suit your needs.

Lines 15 and 16 save the dated form to a new file on my Desktop and quit PDFpenPro.

I now have a one-step method for generating a W-9 to send to my client. No hunting for the template, no typing, no worries about overwriting the template. I just call the AppleScript via FastScripts and the filled-in form appears on my Desktop.

FastScripts isn’t necessary, of course. It’s just what I’m used to. You can use any one of the seemingly endless methods for calling a script.

An obvious extension to this script would be to add a section that creates a new mail message with some “Here is your W-9” boilerplate and the filled-in form attached. An exercise for a later date. There’s only so much AppleScript I can take in one day.

Today I was going to use my coordinate script to set the location of several dozen photos I took with a standard, non-GPS-equipped camera. I’d taken a photo in the same location with my iPhone, and I intended to use the command

coordinate -g iphone.jpg IMG*

to take the GPS location embedded in the iPhone photo and put it in the other photos. In fact, the only reason I took the iPhone photo was to use it to extract the GPS info. Well, this scheme went agley. Apparently, I took the iPhone photo before its GPS had figured out where it was, so the coordinates in it were useless.

I shifted to my backup plan: get the location from Google Maps and use the less automated form of coordinate, where I include the latitude and longitude explicitly on the command line. Unfortunately, I had written coordinate to expect the input in dd:mm:ss.ss format, not the decimal degrees format that Google gives you when you use its “Drop LatLng Marker” feature.¹

It’s not the hardest thing in the world to convert from decimal degrees to degrees, minutes, and seconds, but it seemed like something coordinate should do for me.

Now it does. Here’s the new code:

python:
  1:  #!/usr/bin/env python
  2:  
  3:  import pyexiv2
  4:  import getopt
  5:  import sys
  6:  from fractions import Fraction
  7:  from functools import partial
  8:  from math import modf
  9:  
 10:  usage = """Usage: coordinate [options] [files]
 11:  
 12:  Options:
 13:    -g filename    photo file with GPS coordinates
 14:    -n angle       north coordinate
 15:    -s angle       south coordinate
 16:    -e angle       east coordinate
 17:    -w angle       west coordinate
 18:    -h             show this help message
 19:  
 20:  Add location metadata to each of the listed files. The location
 21:  can come from either the photo associated with the -g option or
 22:  with a -n, -s, -e, -w pair given on the command line. The angles
 23:  can be in either d.dddddd or dd:mm:ss.sss format."""
 24:  
 25:  # Functions for manipulating coordinates.
 26:  def makecoord(coordstring):
 27:    """Make a coordinate list from a coordinate string.
 28:    
 29:    The string can be either "d.ddddd" or "dd:mm:ss.ss", and the
 30:    list comprises three Fractions."""
 31:    
 32:    if ':' not in coordstring:
 33:      theta = float(coordstring)
 34:      m, d = modf(theta)
 35:      s, m = modf(m*60)
 36:      s = s*60
 37:      angle = [ str(x) for x in [d, m, s] ]
 38:    else:
 39:      angle = coordstring.split(':', 2)
 40:    
 41:    loc = [ Fraction(x).limit_denominator(1000) for x in angle ]
 42:    return loc
 43:    
 44:  def setcoord(metadata, direction, coordinate):
 45:    """Set the latitude or longitude coordinate.
 46:    
 47:    Latitude is set if direction is 'N' or 'S', longitude if 'E' or 'W'.
 48:    The coordinate is a list of the form [dd, mm, ss], where the degrees,
 49:    minutes, and seconds are Fractions."""
 50:    
 51:    tags = {'lat': ('Exif.GPSInfo.GPSLatitudeRef', 'Exif.GPSInfo.GPSLatitude'),
 52:            'lon': ('Exif.GPSInfo.GPSLongitudeRef', 'Exif.GPSInfo.GPSLongitude')}
 53:    if direction in ('N', 'S'):
 54:      coord = 'lat'
 55:    else:
 56:      coord = 'lon'
 57:    metadata[tags[coord][0]] = direction
 58:    metadata[tags[coord][1]] = coordinate
 59:  
 60:  
 61:  # Get the command line options.
 62:  try:
 63:    options, filenames = getopt.getopt(sys.argv[1:], 'g:n:s:e:w:h')
 64:  except getopt.GetoptError, err:
 65:    print str(err)
 66:    sys.exit(2)
 67:  
 68:  # Set the option values.
 69:  gpsphoto = north = south = east = west = False       # defaults
 70:  for o, a in options:
 71:    if o == '-g':
 72:      gpsphoto = a
 73:    elif o == '-n':
 74:      north = makecoord(a)
 75:    elif o == '-s':
 76:      south = makecoord(a)
 77:    elif o == '-e':
 78:      east = makecoord(a)
 79:    elif o == '-w':
 80:      west = makecoord(a)
 81:    else:
 82:      print usage
 83:      sys.exit()
 84:  
 85:  
 86:  # Valid option combinations.
 87:  ne = (north and east) and not (south or west or gpsphoto)
 88:  nw = (north and west) and not (south or east or gpsphoto)
 89:  se = (south and east) and not (north or west or gpsphoto)
 90:  sw = (south and west) and not (north or east or gpsphoto)
 91:  gps = gpsphoto and not (north or south or east or west)
 92:  
 93:  if not (ne or nw or se or sw or gps):
 94:    print "invalid location"
 95:    sys.exit()
 96:  
 97:  
 98:  # Create the coordinate setter functions.
 99:  if ne:
100:    setlat = partial(setcoord, direction='N', coordinate=north)
101:    setlon = partial(setcoord, direction='E', coordinate=east)
102:  elif nw:
103:    setlat = partial(setcoord, direction='N', coordinate=north)
104:    setlon = partial(setcoord, direction='W', coordinate=west)
105:  elif se:
106:    setlat = partial(setcoord, direction='S', coordinate=south)
107:    setlon = partial(setcoord, direction='E', coordinate=east)
108:  elif sw:
109:    setlat = partial(setcoord, direction='S', coordinate=south)
110:    setlon = partial(setcoord, direction='W', coordinate=west)
111:  elif gps:
112:    basemd = pyexiv2.ImageMetadata(gpsphoto)
113:    basemd.read()
114:    latref = basemd['Exif.GPSInfo.GPSLatitudeRef']
115:    lat = basemd['Exif.GPSInfo.GPSLatitude']
116:    lonref = basemd['Exif.GPSInfo.GPSLongitudeRef']
117:    lon = basemd['Exif.GPSInfo.GPSLongitude']
118:    setlat = partial(setcoord, direction=latref.value, coordinate=lat.value)
119:    setlon = partial(setcoord, direction=lonref.value, coordinate=lon.value)
120:  else:
121:    print "coordinate setter failed"
122:    sys.exit()
123:  
124:  # Cycle through the files.
125:  for f in filenames:
126:    md = pyexiv2.ImageMetadata(f)
127:    md.read()
128:    setlat(md)
129:    setlon(md)
130:    md.write()

The new parts are in the makecoord function, Lines 26-42. If the coordinate given on the command line doesn’t include a colon, it’s assumed to be in decimal degrees, and Lines 33-37 turn it into a three-item list of strings appropriate for the conversion to Fractions that occurs on Line 41. If the coordinate does include a colon, it’s treated as before on Line 39.

I used a new (to me) function: modf from the math library. It takes a floating point number as its argument and returns the fractional and integer parts as a tuple. Strangely, the fractional part comes before the integer part in the tuple. I assumed it was the other way around when I first wrote Lines 34-35, which led to some surprising results.

Now I can copy the coordinates from a LatLng marker and, with just a little editing on the command line, use them directly in the coordinate command:

coordinate -n 41.87658 -w 87.61912 *.jpg

I should have written the script this way in the first place.

I’m curious about the background in that embedded tweet of mine. My Twitter profile background is solid blue, and I don’t have a background image set. Looking up one of my tweets with the API, though, I see that my profile_background_image_url variable points to that pixelated background in the embedded tweet. I recognize it as a background image that I used a while ago. It would appear that hitting ‘Remove background’ on the Twitter ‘Design Settings’ page just flips a switch to show the color and not a background image, while the image itself remains attached to the profile. And since background images trump colors in CSS, that’s why my embedded tweet features that old image! Strange.

Luckily the bug was easy to fix.

My system for displaying embedded tweets is called Blackbird.py. It’s my fork of Jeff Miller’s Python reimplementation of Robin Sloan’s original Blackbird Pie. A few weeks ago I did a significant rewrite, stealing a few ideas from Twitter’s own embedded tweet implementation to make tweets look better in the RSS feed. In doing so, I needed to add some JavaScript/jQuery code to the system to get the look I wanted here on ANIAT itself.

As of yesterday, the background was set with the line

$("#" + divID).css('background', 'url(' + data.user.profile_background_image_url + ') #' + data.user.profile_background_color);

which, for Matthew’s tweet that I quoted yesterday, is the jQuery equivalent of this CSS:

#t163374655128862720 {
  background: url(https://si0.twimg.com/profile_background_images/15300442/Static.png) #0BAEE5;
}

(That long string with a t followed by several digits is the id of the <div> that contains the embedded tweet. The digits come from the status ID of the tweet, and the t stands for “tweet.”)

If the image is available, it will be displayed. As Matthew discovered, Twitter doesn’t delete the image when you choose “Remove background” from your design settings—it just flips the value of a Boolean variable.

That Boolean variable is called profile_use_background_image, and it’s available in the user section of the data returned by the statuses/show command of the Twitter API. By changing the JavaScript to

if (data.user.profile_use_background_image == true) {
  $("#" + divID).css('background', 'url(' + data.user.profile_background_image_url + ') #' + data.user.profile_background_color);
}
else {
  $("#" + divID).css('background', '#' + data.user.profile_background_color);
}

the embedded tweet respects the user’s choice of background.

The new code is in the Blackbird.py GitHub repository and has been installed here. Because it’s JavaScript and changes the page on the fly, Matthew’s tweet, which had the wrong background yesterday, has the right background today. Like this:

So now when people read yesterday’s post and see his comment about a pixelated background image, they’ll think he’s nuts. I can live with that.

$("#" + divID + " a").css('color', '#' + data.user.profile_link_color);

This relatively simple fraction generates a decimal number that contains, in order, every three-digit sequence from 000 to 999 (except, sadly, 998). Pretty cool.

If it’s true. I don’t want to be cynical or disparage the integrity of the people who’ve been posting this, but folks on the internet don’t always get their math right. Shocking, I know.

So I was going to see if I could generate the decimal and check, but it slipped my mind until Matthew McVickar (Hawaii’s latest musical superstar, successor to Don Ho and Israel Kamakawiwoʻole), reminded me of it on Twitter.

Hmmm… I’m not sure how to take the “naïveté” comment, but I appreciate the diacritical marks.

When you need an answer to 3000 decimal places, you can’t just open up Octave and type in the fraction. Double precision floating point is going to come up about 2983 places short. The easiest way to check the fraction is to enter it in Wolfram Alpha. It’ll start out truncated, but you can keep asking for more digits until you get enough. The problem with Alpha is that the answer isn’t very nicely formatted.

I decided to try Python’s decimal library, a library I’d never used before. It’s main claim is its ability to represent decimals exactly rather than with the rounding and truncation associated with floating point arithmetic, but it can also handle huge numbers of decimal places.

Here’s a quick script to print out the decimal in a form that’s easy to read:

python:
 1:  #!/usr/bin/python
 2:  
 3:  from decimal import *
 4:  from sys import stdout
 5:  
 6:  getcontext().prec = 3000
 7:  num = Decimal(1)
 8:  denom = Decimal(998001)
 9:  dec = str(num/denom)[2:3002]
10:  
11:  for i,c in enumerate(dec):
12:    if i % 30 == 29:
13:      stdout.write(c + "\n")
14:    elif i % 3 == 2:
15:      stdout.write(c + " ")
16:    else:
17:      stdout.write(c)

Line 6 sets the precision to 3000 decimal places. Lines 7 and 8 set the numerator and denominator using the library’s Decimal constructor. Line 9 does the division, converts the result to string form, and extracts the 3000 characters after the decimal point. Lines 11-17 print out the result in lines of 30 characters, with spaces between every set of 3. There’s probably a clever way to get the same output with the format command, but I haven’t used format enough to be comfortable with it.

Here’s the result

000 001 002 003 004 005 006 007 008 009
010 011 012 013 014 015 016 017 018 019
020 021 022 023 024 025 026 027 028 029
030 031 032 033 034 035 036 037 038 039
040 041 042 043 044 045 046 047 048 049
050 051 052 053 054 055 056 057 058 059
060 061 062 063 064 065 066 067 068 069
070 071 072 073 074 075 076 077 078 079
080 081 082 083 084 085 086 087 088 089
090 091 092 093 094 095 096 097 098 099
100 101 102 103 104 105 106 107 108 109
110 111 112 113 114 115 116 117 118 119
120 121 122 123 124 125 126 127 128 129
130 131 132 133 134 135 136 137 138 139
140 141 142 143 144 145 146 147 148 149
150 151 152 153 154 155 156 157 158 159
160 161 162 163 164 165 166 167 168 169
170 171 172 173 174 175 176 177 178 179
180 181 182 183 184 185 186 187 188 189
190 191 192 193 194 195 196 197 198 199
200 201 202 203 204 205 206 207 208 209
210 211 212 213 214 215 216 217 218 219
220 221 222 223 224 225 226 227 228 229
230 231 232 233 234 235 236 237 238 239
240 241 242 243 244 245 246 247 248 249
250 251 252 253 254 255 256 257 258 259
260 261 262 263 264 265 266 267 268 269
270 271 272 273 274 275 276 277 278 279
280 281 282 283 284 285 286 287 288 289
290 291 292 293 294 295 296 297 298 299
300 301 302 303 304 305 306 307 308 309
310 311 312 313 314 315 316 317 318 319
320 321 322 323 324 325 326 327 328 329
330 331 332 333 334 335 336 337 338 339
340 341 342 343 344 345 346 347 348 349
350 351 352 353 354 355 356 357 358 359
360 361 362 363 364 365 366 367 368 369
370 371 372 373 374 375 376 377 378 379
380 381 382 383 384 385 386 387 388 389
390 391 392 393 394 395 396 397 398 399
400 401 402 403 404 405 406 407 408 409
410 411 412 413 414 415 416 417 418 419
420 421 422 423 424 425 426 427 428 429
430 431 432 433 434 435 436 437 438 439
440 441 442 443 444 445 446 447 448 449
450 451 452 453 454 455 456 457 458 459
460 461 462 463 464 465 466 467 468 469
470 471 472 473 474 475 476 477 478 479
480 481 482 483 484 485 486 487 488 489
490 491 492 493 494 495 496 497 498 499
500 501 502 503 504 505 506 507 508 509
510 511 512 513 514 515 516 517 518 519
520 521 522 523 524 525 526 527 528 529
530 531 532 533 534 535 536 537 538 539
540 541 542 543 544 545 546 547 548 549
550 551 552 553 554 555 556 557 558 559
560 561 562 563 564 565 566 567 568 569
570 571 572 573 574 575 576 577 578 579
580 581 582 583 584 585 586 587 588 589
590 591 592 593 594 595 596 597 598 599
600 601 602 603 604 605 606 607 608 609
610 611 612 613 614 615 616 617 618 619
620 621 622 623 624 625 626 627 628 629
630 631 632 633 634 635 636 637 638 639
640 641 642 643 644 645 646 647 648 649
650 651 652 653 654 655 656 657 658 659
660 661 662 663 664 665 666 667 668 669
670 671 672 673 674 675 676 677 678 679
680 681 682 683 684 685 686 687 688 689
690 691 692 693 694 695 696 697 698 699
700 701 702 703 704 705 706 707 708 709
710 711 712 713 714 715 716 717 718 719
720 721 722 723 724 725 726 727 728 729
730 731 732 733 734 735 736 737 738 739
740 741 742 743 744 745 746 747 748 749
750 751 752 753 754 755 756 757 758 759
760 761 762 763 764 765 766 767 768 769
770 771 772 773 774 775 776 777 778 779
780 781 782 783 784 785 786 787 788 789
790 791 792 793 794 795 796 797 798 799
800 801 802 803 804 805 806 807 808 809
810 811 812 813 814 815 816 817 818 819
820 821 822 823 824 825 826 827 828 829
830 831 832 833 834 835 836 837 838 839
840 841 842 843 844 845 846 847 848 849
850 851 852 853 854 855 856 857 858 859
860 861 862 863 864 865 866 867 868 869
870 871 872 873 874 875 876 877 878 879
880 881 882 883 884 885 886 887 888 889
890 891 892 893 894 895 896 897 898 899
900 901 902 903 904 905 906 907 908 909
910 911 912 913 914 915 916 917 918 919
920 921 922 923 924 925 926 927 928 929
930 931 932 933 934 935 936 937 938 939
940 941 942 943 944 945 946 947 948 949
950 951 952 953 954 955 956 957 958 959
960 961 962 963 964 965 966 967 968 969
970 971 972 973 974 975 976 977 978 979
980 981 982 983 984 985 986 987 988 989
990 991 992 993 994 995 996 997 999 000

Formatting the output this way makes it easy to see that the claim is correct. Too bad about the missing 998.

I get many visits from people following links from the t.co domain, Twitter’s own link shortening service. That isn’t unusual. Like many bloggers, I often tweet a link to a post I’ve just written. But when a post I didn’t tweet about starts getting hits from t.co, it means someone else has tweeted a link to me. Obviously, if my Twitter handle is included in the tweet, there’s no mystery; I’ll probably already have seen the link in my mentions. Sometimes, though, the link comes without a mention, and if I have the time I try to find out who did it.

Yesterday morning I was home from work, trying to fight off the beginning of a cold (unsuccessfully), so I had the time. I went to twitter.com and searched for “leancrew.” Twitter initially shows the “top” tweets, using whatever algorithm it has for determining “top,” but you can switch to “all” tweets from a little popup menu near the top of the page.

When I did that, a bunch of obvious spam appeared in the results.

“Leancrew” didn’t appear in any of these tweets, but by hovering over the link I could see the URL of one of my posts in the popup.

WTF? You won’t be surprised to learn, I’m sure, that clicking those link takes you not to my post but to a site that purports to be giving away iPads. So why does the little popup show one of my URLs?

My understanding of that popup is that it’s supposed to show the resolved URL of the link, that is, the URL at the end of the redirect chain. For example, if you just post a regular, direct URL into your tweet, Twitter will turn it into a short t.co link which redirects to the original. That’s one step of redirection. If, however, you paste a j.mp link into your tweet, Twitter wraps that into a t.co link before posting and you now have two steps of redirection: from t.co to j.mp and then from j.mp to the original site.

Some of this information is included in the tweet entities section of the tweet. For example, let’s look at this non-spam tweet:

By going to Twitter’s Exploring the Twitter API page we can see what this tweet is composed of by issuing a GET on the URL

https://api.twitter.com/1/statuses/show.json?id= 163262396130017281&include_entities=true

In the JSON that’s returned, the entities part looks like this:

"entities":  {
   "user_mentions":  [],
   "urls":  [
      {
       "url": "http://t.co/2ukW7OSE",
       "display_url": "j.mp/AlbEFV",
       "indices":  [
         37,
         57
       ],
       "expanded_url": "http://j.mp/AlbEFV"
     }
   ],
   "hashtags":  []
 },

The url is the t.co-shortened link that Twitter made, the expanded_url is the j.mp URL you pasted into the tweet,¹ and display_url is the text that appears in the tweet.

If you look at this tweet on its own page, you’ll see that the popup shows the expanded_url.

But if you look at it in search results or a timeline, the popup shows the resolved URL that j.mp redirects to.

So what does this have to do with the spam tweets I saw? Well, if I GET one of the spams, the entities section is

"entities":  {
  "urls":  [
     {
      "url": "http://t.co/mNL7S05v",
      "display_url": "hi24.info/c1b",
      "expanded_url": "http://hi24.info/c1b",
      "indices":  [
        15,
        35
      ]
    }
  ],
  "user_mentions":  [
     {
      "id_str": "421544542",
      "name": "Sifri y Quique",
      "screen_name": "quiquesifri96",
      "indices":  [
        0,
        14
      ],
      "id": 421544542
    }
  ],
  "hashtags":  []
},

which is very much like @macdrifter’s tweet, with hi24.info URLs taking the place of the j.mp URLs.²

Somehow, then, when Twitter resolves that hi24.info URL to make the popup, it resolves to my post; but when a user clicks on it in a browser, it resolves to the spam page offering free iPads.

There’s actually quite a long chain of redirects associated with that hi24.info URL. When I pass it to wget, I get this reponse:

$ wget http://hi24.info/c1b
--2012-01-28 09:04:41--  http://hi24.info/c1b
Resolving hi24.info... 173.208.182.10
Connecting to hi24.info|173.208.182.10|:80... connected.
HTTP request sent, awaiting response... 302 Moved Temporarily
Location: http://oldcarreviews.info/index.php?t=1327316945403 [following]
--2012-01-28 09:04:41--  http://oldcarreviews.info/index.php?t=1327316945403
Resolving oldcarreviews.info... 66.85.156.14
Connecting to oldcarreviews.info|66.85.156.14|:80... connected.
HTTP request sent, awaiting response... 302 Moved Temporarily
Location: http://google.com/ [following]
--2012-01-28 09:04:43--  http://google.com/
Resolving google.com... 74.125.225.147, 74.125.225.148, 74.125.225.144, ...
Connecting to google.com|74.125.225.147|:80... connected.
HTTP request sent, awaiting response... 301 Moved Permanently
Location: http://www.google.com/ [following]
--2012-01-28 09:04:44--  http://www.google.com/
Resolving www.google.com... 74.125.225.114, 74.125.225.115, 74.125.225.116, ...
Connecting to www.google.com|74.125.225.114|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified [text/html]

To me, the weirdest thing is after redirecting to oldcarrierreviews.info, it redirects to google.com (twice). I don’t understand how a google.com request ends up at a spam page.

Anyway, to bring this rambling post to a close, my guess is that h124.info uses the headers of the HTTP request to figure out whether it’s getting an inquiry from Twitter or from a normal browser. If it’s from Twitter, it returns an inoffensive URL (like mine); if it’s from a browser (or wget), it sets off the chain of redirects that lands at the spam page.

I’m kind of pissed at this. I don’t want my domain associated with spam, but I don’t know how to stop it. It’s similar to when email spam spoofs your address, but I think most people know by now that email addresses can be spoofed. Twitter’s stated reason for wrapping all links in t.co redirects is to reduce spam and keep us safe. In this case, not only is the spam getting through (the @bandurazqoeb3 and @klughadmq0 accounts are still active as I write this), but the users getting these spams would be justified in thinking I have something to do with them.

I tweeted a complaint to Twitter’s @spam account but got no response. When I’m done posting this, I’ll go through the steps in this security form to report the issue. But I don’t see my career as an inadvertent Twitter spammer ending soon.

Here’s the updated map script:

python:
 1:  #!/usr/bin/python
 2:  
 3:  import pyexiv2
 4:  import sys
 5:  import subprocess
 6:  import getopt
 7:  
 8:  usage = """Usage: map [option] file
 9:  
10:  Options:
11:    -b    use Bing instead of Google Maps
12:    -h    show this help message
13:  
14:  Get the GPS data from the given image file and open a map to that
15:  location in the user's default browser."""
16:  
17:  # Parse the options.
18:  try:
19:    options, photos = getopt.getopt(sys.argv[1:], 'bh')
20:  except getopt.GetoptError, err:
21:    print str(err)
22:    sys.exit(2)
23:  
24:  # Set the option values.
25:  engine = 'google'           # default
26:  for o, a in options:
27:    if o == '-b':
28:      engine = 'bing'
29:    else:
30:      print usage
31:      sys.exit()
32:  
33:  try:
34:    # Open the photo file.
35:    md = pyexiv2.ImageMetadata(photos[0])
36:    md.read()
37:  except:
38:    print usage
39:    sys.exit()
40:  
41:  try:
42:    # Read the GPS info.
43:    latref = md['Exif.GPSInfo.GPSLatitudeRef'].value
44:    lat = md['Exif.GPSInfo.GPSLatitude'].value
45:    lonref = md['Exif.GPSInfo.GPSLongitudeRef'].value
46:    lon = md['Exif.GPSInfo.GPSLongitude'].value
47:  except KeyError:
48:    print "No GPS data for %s" % photos[0]
49:    sys.exit(1)
50:  
51:  # Convert the latitude and longitude to signed floating point values.
52:  latitude = float(lat[0]) + float(lat[1])/60 + float(lat[2])/3600
53:  longitude = float(lon[0]) + float(lon[1])/60 + float(lon[2])/3600
54:  if latref == 'S': latitude = -latitude
55:  if lonref == 'W': longitude = -longitude
56:  
57:  # Construct the Google Maps or Bing Maps query and open it.
58:  if engine == 'bing':
59:    query = "http://www.bing.com/maps/?v=2&where1=%.6f,%.6f" % (latitude, longitude)
60:  else:
61:    query = "http://maps.google.com/maps?q=loc:%.6f,%.6f" % (latitude, longitude)
62:  subprocess.call(['open', query])

It’s quite a bit longer than before, mostly because of the option handling code in Lines 17-31 and the usage message in Lines 8-15. I’ve also separated the error handling into two try/except clauses, one for dealing with errors in opening the image file and the other for handling files with no location. (Note also that Line 49 has map return a nonzero result code if there’s no GPS info. We’ll use that in the service.)

Otherwise, it’s basically the same script. Use

map photo.jpg

to open a Google Maps view of the photo’s location in your default browser. Use

map -b photo.jpg

to open the location in Bing Maps instead.

The “Photo location” service is defined this way in Automator:

It’s defined only for image files selected in the Finder and runs the following shell script:

bash:
1:  for f in "$@"
2:  do
3:    ~/bin/map "$f"
4:    if [ $? -ne 0 ]; then
5:     say "No location"
6:    fi
7:  done

For every selected image file, it runs the map program. If the map command in Line 3 returns a nonzero result code, $?—which it will if the image file has no location metadata—the script will say “No location” in the user’s default voice. If you want to use this service, but find the talking a bit too cute, you can change Line 5 to

bash:
5:     osascript -e "beep 1"

and it will sound the system alert if the file has no GPS data. If you’d rather use Bing, slip a -b after the map in Line 3. Or you could make two services, one that uses Google and one that uses Bing.

With these improvements, I think I’m done. I have a tool that works the way I want on my computers. I could rewrite map to use an EXIF library that’s easier to install than pyexiv2, possibly switching to Perl or Ruby in the process, but since I managed to get pyexiv2 installed on my machines, I’d get no benefit out of doing so. But if someone else takes this code and rewrites if for another library, I’d love to hear about it.

The October program is called coordinate, and I use it like this:

coordinate -g iphone-photo.jpg IMG*

This reads the GPS metadata from the iphone-photo.jpg file and writes it to all the files that start with IMG. The new program is called map, and when I call it,

map photo.jpg

it reads the GPS info from the image file and opens Google Maps in my browser with a marker at the photo’s location.

Here’s the code for map:

python:
 1:  #!/usr/bin/python
 2:  
 3:  import pyexiv2
 4:  import sys
 5:  import subprocess
 6:  
 7:  try:
 8:    # Open the photo file.
 9:    photo = sys.argv[1]
10:    md = pyexiv2.ImageMetadata(photo)
11:    md.read()
12:  
13:    # Read the GPS info.
14:    latref = md['Exif.GPSInfo.GPSLatitudeRef'].value
15:    lat = md['Exif.GPSInfo.GPSLatitude'].value
16:    lonref = md['Exif.GPSInfo.GPSLongitudeRef'].value
17:    lon = md['Exif.GPSInfo.GPSLongitude'].value
18:  
19:  except:
20:    print "No GPS info in file %s" % photo
21:    sys.exit()
22:  
23:  # Convert the latitude and longitude to signed floating point values.
24:  latitude = float(lat[0]) + float(lat[1])/60 + float(lat[2])/3600
25:  longitude = float(lon[0]) + float(lon[1])/60 + float(lon[2])/3600
26:  if latref == 'S': latitude = -latitude
27:  if lonref == 'W': longitude = -longitude
28:  
29:  # Construct the Google Maps query and open it.
30:  query = "http://maps.google.com/maps?q=loc:%.6f,%.6f" % (latitude, longitude)
31:  subprocess.call(['open', query])

It uses the standard sys and subprocess libraries and the distinctly non-standard pyexiv2 library. Installing pyexiv2 isn’t the hardest thing in the world, but it takes more than a simple pip pyexiv2. I have a writeup on how to do it via Homebrew if you’re interested.

The script is easy to read, I think. Lines 9-17 get the name of the file from the command line, open it, and extract the GPS information. If there’s a problem in any of those steps, an exception is raised, and Lines 20-21 print an error message and quit.

Because the latitude and longitude are returned in an odd format (a list of three Fractions, one each for degrees, minutes, and seconds), Lines 24-27 are needed to put them in a format we can use to query Google Maps. The query is then constructed in Line 30, and Line 31 sends it to OS X’s wonderfully useful open command to be opened in the default browser. The Google Maps API automatically drops a marker at the location and centers the map around the marker.

I could extend the query with more parameters to set the zoom level, force the display to satellite, map, or street view, and so on, but I prefer to stick with the defaults.

There are some obvious improvements I could make:

• Add an option to use Bing instead of Google Maps. With aerial photos, Bing’s oblique bird’s eye view is often more useful than Google’s top view. I haven’t looked yet, but I assume Bing can be queried through the URL just like Google Maps can.
• Rewrite it for a library that’s easier to install than pyexiv2. This wouldn’t affect me, but would make it easier for others to use.
• Turn it into a Service. This is a trivial change that would produce a big improvement in usability. With a Service, I could just right-click on an image in the Finder and get the location by choosing an item from the popup menu.

If you’re wondering why I don’t just use iPhoto’s built-in mapping tools, it’s because I don’t use iPhoto. I find it very clunky and slow, and its organization system doesn’t work for the photos I take for my job (which is most of my photos). The map script gives me a quick way to check the location of any photo, regardless of where it’s stored on my computer.

There are a bunch of expense tracking apps for the iPhone. Most of them either require you to open some sort of web-based account, which I didn’t want for privacy reasons, or ask you to enter a bunch of information on your phone, which I didn’t want for tedium reasons. After looking things over, I decided to combine a few things I use already: JotNot Scanner Pro, email, and a Numbers expense report template.

I wrote about JotNot back in October. It’s a simple app that uses your iPhone camera as a scanner. What makes it different from the standard Camera app is that it crops, straightens, corrects for perspective, and equalizes the tone of your photos.

It turns out that this, combined with its ability to email the adjusted image, is all I really need.

In the past, I’d collect receipts during my trip and staple them to my expense report, which I’d make out when I got back to the office. This was pretty simple and hard to beat for efficiency, although I did have to be careful to keep my receipts together until the trip was over. If a client wanted a copy of my receipts, I’d lay them out on our scanner and turn them into a PDF that I could email along with the invoice. This was the part I hated. My company’s scanner, although networked, can’t be run from my Mac. I have to save the scans to a Windows machine and then log on to that computer from mine to get at them. If the scanner messes up—OK, if I mess up in using the scanner—I have to go back and forth between offices to redo it.

Scanning receipts in JotNot and mailing them to myself turns out to be really convenient. By default, JotNot puts its name in the text of the email, so when I get back to the office, I just search for “JotNot” in my inbox and drag the various receipts out of their mail messages and into my Numbers expense report.

There’s not much to my expense report. It’s just a simple Numbers template, a single sheet with two tables on it—one for the date of the report and one for the expenses themselves. I’m not a big fan of Numbers, but the ability to lay out separate tables on the same sheet works nicely for this kind of document. The date of the report doesn’t have to be regimented into the same grid structure as the expense details.

As I said, I drag the emailed receipts out of Mail and into Numbers, putting them on separate pages so they don’t block the table. The Show Print View command from the View menu is handy for making sure the edges of the receipts don’t leak over onto other pages. I print out a copy for our bookkeeper to use when comes in to cut our expense checks and “print” another copy as a PDF to email to the client along with the invoice.

Numbers allows you to rotate and resize images, so it’s easy to squeeze several receipts onto a single page. One thing I don’t like, and don’t understand, is that images dragged into Number always appear initially at the upper left corner of the first page, not where I “let go” of them. So after dragging them into Numbers, I have to drag them around within Numbers to get them where I want. This could be improved.¹

There is, obviously, not much to my expense report template, but if you want to use it as a starting point to make one of your own, you can download a zip file of it. After expanding it, just double-click on the file to open it in Numbers. Make the changes you need, then choose Save As Template… from the File menu. It’ll available to choose from the template picker whenever you want to make a new spreadsheet.

Title bar, tool bar, bookmarks bar, tab bar. The main difference between this browser sediment and river sediment is that these layers accumulate at the top instead of the bottom.¹

The one thing I sort of disagree with is this:

The problem is that people like me (and I bet most readers here) can’t even see that there’s a jumble; the sediments of infrastructure are clearly separated in our understanding and thus our eyes. But occasionally I get a flash of how it must look to civilian eyes, and it doesn’t make me happy.

As one of his commenters, Ben Meadowcroft, said, the browsers of non-expert users usually have even more layers. I was reminded of this bit from Mike Lacher’s epic tale from McSweeney’s on fixing a non-expert’s computer:

With a resounding click he opened Internet Explorer 6 and gazed deep into its depths, past the Yahoo toolbar, the MSN toolbar, the Ask.com toolbar, and the AOL toolbar. And then did he see, at long last, that The Google did load.

My mom’s computer has some awful, branded version of Internet Explorer running on it, and the toolbars take up so much of the window it feels like you’re looking at the web between the slats of Venetian blinds. But she likes all that crap. When I’ve suggested getting rid of some of the tool bars, she’s been horrified; it wouldn’t be her familiar web experience without them.

I’ve always thought this was the real story behind the software that John Gruber highlights in his occasional User Interface of the Week posts. It’s not so much that the designers of these applications have no taste, it’s that their users have no taste. There’s something about an ugly, cluttered user interface that says “computer” to the great majority of users out there.