Some Tool Tips

As long time readers know, I am always looking for ways to make my work flow more nearly frictionless. This mainly involves adapting my existing tools (especially Emacs) and adopting new tools. I recently came across a couple of posts that address these. Since they seem generally useful, I thought they were worth sharing.

The first, 10 Tools, Tips,and Tricks to Hack Your Workflow, by Dann Berg looks at 10 tools that he uses to make his day more efficient. These range from Credit Karma—used to track your credit rating—to the excellent (Mac OS X based) Quicksilver. I already use a couple of tools from his list and am planning to check out a couple of others. This is a reasonably short post that gives reasons for his recommendations. The post is well worth a look; you may find something you’ll find useful.

The second post, 9 Enhancements to Shell and Vim Productivity, by Daniel Miessler addresses ways of adapting tools you may already have or replacing one tool with a similar, superior one. Obviously Miessler is a Vim user so the righteous will skip over those tips (although Vim users are apt to find them useful) but he has some good ideas. Again, this post is worth a read

Posted in General | Leave a comment

mu4e

DJCB over at EMACS-FU is announcing the release of Version 0.9.9 of mu4e, his Emacs-based email client. It looks good enough that I am tempted to give up the native Mac email client1. It has dynamic folders that will move messages to different folders depending on context. You can write Elisp functions to control that context so it’s very flexible.

A related feature is refiling that will automatically store received messages based on context. Usually you would want this based on the sender’s email address but, like dynamic folders, it’s configurable by writing Elisp code so should handle special requirements easily.

The most significant feature for me is the encryption/signing functionality. DJCB says that it’s still a little rough but rough is better than none at all which, as the footnote explains, is the predicament that OS X 10.8 users find themselves in.

Head on over to EMACS-FU and take a look at the new features (or see the NEWS file) for mu4e. It looks like an excellent application.

Footnotes:

1 Especially since the GPGmail plugin that supports encryption and signing doesn’t work with Mountain Lion. That has stopped me from upgrading while I wait for the fix.

Posted in General | Tagged | 1 Comment

Comment Spam

Patrick Lambert over at Dendory Blog has a really nice solution to comment spam. He noticed that he never receives any comment spam and decided to investigate why. It turns out that his immunity is an artifact of the way he handles comment submission on his two blogs.

Spam bots work by reading the HTML for the comment section, capturing the variable names for fields, and then sending the data to whatever blogging engine the site uses. Lambert’s sites post comments by calling a Javascript function that internally renames the variables. That means that the spam bots are using the wrong variable names when they try to send the data directly.

Head on over to Lambert’s post for the details. If you’re writing your own processing code this is a technique worth knowing about. If you can write in PHP, perhaps you could even modify a WordPress site although that would introduce a maintenance problem. We could, I suppose, ask the WordPress folks to do something similar but as soon as the practice became widespread we’d see the scum spammers adapt.

Posted in General | Tagged | Leave a comment

The Google Common Lisp Style Guide

Google has made their Common Lisp Style Guide—presumably from ITA—available to the public. As with any style guide, almost everyone will find something to disagree with but by and large it appears to be a very reasonable compendium of best practices. One of the things I like about the guide is that it gives a rationale for each of the rules. That makes the guide feel more like “best practices” than a diktat from the suits.

ITA, of course, is the canonical example of a commercially successful company that used Lisp to solve a large, complicated problem so their take on best practices deserves the respectful attention of all Lispers. If you write in CL, you should take a look at this guide; it’s got lots a useful ideas.

Posted in Programming | Tagged , | 1 Comment

Motown

Matthew Beale has a really interesting post over at madhatted.com that concerns lessons we can learn from Motown. The “we” in question is the software development community. The post is interesting on its own terms but what really struck me was the story of how Motown worked. Those of us of a certain age are very aware of Motown. They were the record label for groups such as the Supremes, The Four Tops, The Jackson 5, and many, many others. Motown had the highest hits to released singles ratio in history. They had 30 #1 hits during the 1960’s.

For most people that’s ancient history yet as Beale notes they have something to tell us. Here’s how Motown managed to crank out all those hits:

  • Each writing/producing team was required to write 5 new songs a day.
  • At the end of the week, each team presented their 5 best songs to the other teams.
  • Each team got to record their 2 best songs of the week.
  • Each recorded tune was mixed, usually about 15 times by different people.
  • Each mix was turned into a record.
  • The quality control department listened to each record and picked the “A” side that was released and promoted.

This process was so efficient that The Four Tops hit It’s the Same Old Song took just 24 hours to go from writing to release to DJs. That’s really astounding. When was the last time you were able to get anything through the pipeline in 24 hours?

Be sure to read Beale’s post to find out more about the Motown process and what it can tell us about our own processes. Even if you’re not a software developer, you’ll enjoy learning about how Motown managed to turn itself into a hit machine.

Posted in General | 1 Comment

Chibi Scheme

I just ran across an update announcement for Chibi Scheme, a small Scheme intended to be used as an extension language for C programs. It supports the small R7RS language and can be configured at compile time to produce a library as small as 80 kB up to 200 kB for the full-featured installation.

I like the strategy of using Scheme to add functionality to a program that for performance or other reasons must be written in C. You write the low level or performance critical components in C and the rest in Scheme. It’s also easy to enable end-users to extend the program by adding their own code. I’ve done some projects like that and it worked out well. I used Guile for those projects but would be willing to give Chibi a try for any future projects of that sort.

Posted in Programming | Tagged , | Leave a comment

Brian Kernighan Interview

Informit has a nice interview with Brian Kernighan about C and programming today. There is, it seems to me, a tendency to disparage C as an old and no longer useful technology. This is, I think, profoundly wrong, something that Kernighan seems to agree with. I’ve said before that I’m happy to be able to focus on Lisp these days but I’ve spent a lot of time with C and agree with Kernighan that if you can program in C you can, in principal, build any other environment. Programmers who don’t bother learning C because it’s “old” are, in my opinion, doing themselves a great disservice.

Kernighan also talks about publishing and software development as it’s practiced today. This is a good interview and worth your time if you’re serious about your craft. Recommended.

Posted in General | Leave a comment

It Seems I’ve Been Wasting My Time…

…not to mention lots of tin foil.

Posted in General | Tagged | Leave a comment

Securing WordPress Sites

This is another in my series of posts about keeping my blog (and yours) free from malware. Victor Granic over at switchwp has an excellent and reasonably comprehensive post on securing WordPress sites. I came across his post via Sacha Chua’s notes on WordCamp Toronto 2012.

Along with the usual good advice such as keeping WordPress up to date, Granic suggests such things as changing the name of the administrator’s account to help foil automatic exploit tools, setting up comprehensive logging, changing the database table prefix, and setting up SSL mutual authentication for access to the administration screen.

Another useful piece of advice is to install the WordPress Exploit Scanner, Login Security Solution and VaultPress security plugins. He also gives some pointers to further resources for learning how to harden your WordPress site.

If you have a WordPress site you should definitely take a look at this guide. It’s full of good advice and things that you may not have known or thought of. Recommended.

Posted in General | Tagged | 1 Comment

Reader Macros

J.V. Toups over at Dorophone has a nice, short introduction to Common Lisp reader macros. The conventional wisdom is that it’s best to avoid reader macros when you can and the use cases that Toups examines probably fall into that category but they do serve to present some interesting examples that show how reader macros work.

If you’ve ever wondered what reader macros were all about or how they work, this is a good introduction. If you want more, you can get it from Paul Graham’s On Lisp or Doug Hoyte’s Let Over Lambda both of which discuss reader macros.

Posted in Programming | Tagged , | Leave a comment