Efficiency vs Efficacy

• Efficiency

  Efficiency is lack of waste. In some cases, it can mean "lack of waste of money" or "lack of waste of energy".

  Example: You're selling widgets, and you want to make the most money possible. This is an efficiency goal. Widget production cost = waste + materials + labor.

• Efficacy

  Efficacy is effectiveness. It can mean "level of coverage" or "level of positive outcome".

  Example: You're making a vaccine, and you want to make sure everyone gets it. Price is no longer particularly important, only the level of coverage. This is an efficacy goal. Number of people dead = ((people in population) / (people covered))^2 (since transmission is reduced, it's square-law-type)

For example, you want these to be efficient:

• Tax collection
• Luxury good distribution
• Financial services

You want these to be efficacious:

• Medical care
• Car safety
• Welfare services
• Fire and police services
• Education

Yahoo Pipes (Dataflow programming, but don't call it that!)

Pretty interesting stuff. If you've ever worked with LabView or VVVV (Windows-only, but a toolkit that deserves many posts of its own), you know how nifty dataflow programming can be.

I've just started playing around with Yahoo Pipes, late to the party again by about a year, and it's pretty interesting stuff.

As an example, I improved the Craigslist / Zillow mashup that was already on there to do multisegmented feeds (since craigslist limits you to 25 per feed) and to add query, min/max price, and county indicators, since I was interested in those as well.

Right now, it's pretty useful for comparing the real value of houses with the listings on Craigslist. If it's significantly different, be on the lookout for a bargain or a ripoff, or at least ask why it's different (remodels often mess up Zestimates).

Here's the link: Craigslist / Zillow mashup version 2 ( http://pipes.yahoo.com/jaggederest/clpricecheckv2 )

It's pretty typical of dataflow: It's easy to toss things together, but to really get into it you need to build new components, and apparently the only way to do that is via importing pipes, which is nice, but doesn't let me build 'if' statements as I'd like.

As a side note, dataflow is one of the other ways to achieve low-cost parallelism, and one that's often overlooked, I think. People concentrate on actor-model or locks far too often.

Tendency to Hoard stuff? A plan for piles.

I know I tend to pack-rat things. I often find it difficult to clear things up or clean an area out, even when I know most of the stuff in it is junk, or even just something I won't need right away.
Here's my method:

1. Clear it all out.

   It doesn't matter if it goes in a big pile in the middle of the room, just get it out of there. Put it someplace you can't stop until you're done.

2. Sort them out by quality or usefulness

   Ambiguous, yes, but it's really up to the person doing the sorting. Whatever criteria you use to decide whether to keep things when it's one-by-one, use it here, to group things into a set of piles.

   I usually use at least five. The goal is to have equal sized piles. (If you've heard of the bond market, they call this 'tranches', say AAA, AA, A, B, C, etc)

3. Put the first pile back

   Take the pile that is the top shelf stuff, and put it back where you started from. Make it nice, neat, and clean (good time to get dirt off, while it's empty).

4. Assess the situation

   Don't worry about all the other piles, just honestly assess the situation. Is the space clean? Is it clear? Does it have all the things you'd commonly use there?

   Sometimes with this part, it helps to get an outside opinion. Have someone you trust tell you whether it looks good, is cluttered, or is empty. If it's cluttered, split the pile.

5. If it needs more, go to step 3.

   Say you're organizing your drawing desk. Are all your favorite pastels still sitting behind you? Maybe you still need that ruler or the pens that haven't made it in yet. Time to go back, get another pile (the next-best one) and put it away as well.

6. Clean up the other piles

   Here's the fun part: By process of elimination, you've just decide what to store/give away/recycle without ever having to agonize over your favorite pincushion. You can trick yourself into realizing that you don't need so much stuff.

7. You're done.

   You've just reclaimed usable space, and, if you're like me, given away quite a bit to charity, which can take a nice bite out of your tax liabilities.

   Do this often enough, you'll realize how many of the things you thought were 'vital' to have out are really once-a-month or once-a-year items, too.

Git is amazing

So, today, I'm working on a project, I've got it all mocked out with some sample forms and some throwaway objects to play with.

I realize 'Hey, I need an authorization/authentication system', so I have a dilemma.

On the one hand, my code is throwaway that I plan to evolve to fit what I end up actually doing with it long term.

On the other hand, I really don't want to have to redo it later, since I'll probably want to come back here after I build out the auth/auth system.

Git to the rescue.

I've been doing all my development on the 'experimental' branch locally, as one ought to do.

git commit -m 'End of tinkering, time to get serious'

git checkout master #Back to the beginning,
#or you can use git checkout HEAD~x where x is how many commits you want to go back

#create the new branch and check it out
#equivalent of git branch restful_auth; git checkout restful_auth
git checkout -b restful_auth #which is a wonderful plugin, btw

# do your install here...

git commit -m 'All restful, now lets go back to the other'

git checkout experimental

git rebase restful_auth

# fix the conflicts, I had three

And you're done. You just saved yourself a couple hours of rewriting throw-away bits of your app. And of course, this is completely doable with pretty much any type of edit. You can go back into the past and effectively 'redo it right' without having to worry about the time it takes up front.

Ibuprofen, Naproxsyn/Naproxsen, and Aspirin: Don't overdo it.

My girlfriend just got out of the hospital after having a bleeding ulcer as a result of taking ibuprofen, among other stressors.

Just a heads up, any of you who read this, go easy on the ibuprofen, because the effects can be very bad if you are unlucky, and it is surprisingly common.

multiurl

like tinyurl but with multiple pages. Pop page with previews, ask users if they want to open all, one, some, or play slideshow-style in frame?

Perhaps a bookmarklet interface, along the standard HTML paste-in-urls.

Edit: Already exists, ManyURL, works nice from what I see. Could use a bit more, though! Too simple, not complicated enough.

When you're serving static files...

Never link http://yoursite.com/foo/bar/x to:

A) plain http://static.yoursite.com/foo_bar_x.ext

B) Never use plain hashes of the ID. e.g. .../hash_of_id_here.ext

C) Borderline, but even static salts are bad: .../hash_of_id_plus_'foobar'_here.ext

Basic is, use a variable salt for every item. It can ever be public info, like the title, creation time, or anything that varies sufficiently per-item. That's the beauty of salts.

Or, alternatively, as better people than I have mentioned, use bcrypt with a set difficulty value, and all your rainbow table type fears go away.

Emacs...

Biggest reason to switch to emacs I've found so far is that the commands work by default in bash, too.