ShopSimple 1.1

I just released ShopSimple 1.1 on the App Store — tell your friends, neighbors, co-workers, pets, SOs, mail carriers.

Even if I say so myself, it’s a great little shopping list application.


Why ShopSimple?

  • Why do I need to tell my shopping list what brand of toothpaste I buy?

  • Why do I need to tell my shopping list when I’m done shopping?

  • Why do I need I need to add things one. item. at. a. time.?

  • Why does my list have to look so complicated?

  • Why would I want to take photos of the dog food I buy?

The answer: you don’t! ShopSimple: simpler shopping lists because life is already too busy.


Don’t like speed cameras? Use them to punk your enemies

I’m a year behind the times, but this is a good story…

Don’t like speed cameras? Use them to punk your enemies

“Students at Richard Montgomery High School in Maryland have discovered that they can duplicate the license plates of their archenemies by printing a Maryland plate template on a sheet of glossy photo paper and digging up a handy license plate character font, according to a parent speaking to The Sentinel (via /.). This may sound like a janky craft project at first, but these cameras are not sensitive enough to pick up the differences between these paper license plates and the real things. The students then tape the faux plate over their own and purposefully speed in order to be caught by the speed camera, causing the real owner of the license plate to receive a $40 citation in the mail.”

Who monitors the monitors?

I never blog about Lisp. What I use for apropos

(update: several people have mentioned Edi Weitz’s excellent regex apropos. I think that the code below complements the regex approach but that’s mostly because I usually think in terms of “find me a symbol with this and that” rather than in terms of regular expressions).

Apropos is great but simple string matching isn’t enough. I don’t think I’ve blogged about this before (sorry if I have but googling apropos didn’t find any results.

My aproposing code is below. It takes a list of string arguments (using &rest) and returns the symbols that contain every string passed in. If you don’t specify that package, it looks in all of them (like apropos). If you pass in an symbol that names a package, then the search is restricted to that package.

(defun ap (&rest args)
  (let ((package nil)
  (search-list nil))
    (loop for arg in args do
   (if (and (symbolp arg) (find-package arg))
       (setf package (find-package arg))
       (push arg search-list)))
    (%ap (nreverse search-list) package)))

(defgeneric %ap (thing &optional package))

(defmethod %ap ((thing string) &optional package)
  (let ((*package* (or (and package (find-package package))
    (apropos-list thing package)))

(defmethod %ap ((thing symbol) &optional package)
  (%ap (symbol-name thing) package))

(defmethod %ap ((thing list) &optional package)
  (cond ((null thing) nil)
  ((null (rest thing)) (%ap (first thing) package))
   (let ((current (%ap (first thing) package)))
     (dolist (next (rest thing))
       (setf current (intersection current (%ap next package))))

(export 'ap)


> (cl-user::ap "bind" "value")
(multiple-value-bind compiler::pa-multiple-value-bind

> (cl-user::ap "bind" "value" :cl-user)

It works for me! Suggestions, as always, welcome.