Pat Canny Online

MATLAB Script: Dealing Cards

2014-12-29T11:49:00.000-05:00

I played cards (poorly) over Christmas, and thought a good way to break through the end-of-year boredom at work would be to write a quick MATLAB script that dealt a given number of cards from a randomly shuffled deck to a given number of players.

I got to use the eval command again, which is always exciting.

% Randomly shuffle a deck of cards
% Distribute to a given number of players (user input)
% Display the hands for each player

% Assign a number for each card
% 1-13 are for Spades (in order)
% 14-26 are for Clubs
% 27-39 are for Diamonds
% 40-52 are for Hearts
card_names{1} = '2 of Spades';
card_names{2} = '3 of Spades';
card_names{3} = '4 of Spades';
card_names{4} = '5 of Spades';
card_names{5} = '6 of Spades';
card_names{6} = '7 of Spades';
card_names{7} = '8 of Spades';
card_names{8} = '9 of Spades';
card_names{9} = '10 of Spades';
card_names{10} = 'Jack of Spades';
card_names{11} = 'Queen of Spades';
card_names{12} = 'King of Spades';
card_names{13} = 'Ace of Spades';
card_names{14} = '2 of Clubs';
card_names{15} = '3 of Clubs';
card_names{16} = '4 of Clubs';
card_names{17} = '5 of Clubs';
card_names{18} = '6 of Clubs';
card_names{19} = '7 of Clubs';
card_names{20} = '8 of Clubs';
card_names{21} = '9 of Clubs';
card_names{22} = '10 of Clubs';
card_names{23} = 'Jack of Clubs';
card_names{24} = 'Queen of Clubs';
card_names{25} = 'King of Clubs';
card_names{26} = 'Ace of Clubs';
card_names{27} = '2 of Diamonds';
card_names{28} = '3 of Diamonds';
card_names{29} = '4 of Diamonds';
card_names{30} = '5 of Diamonds';
card_names{31} = '6 of Diamonds';
card_names{32} = '7 of Diamonds';
card_names{33} = '8 of Diamonds';
card_names{34} = '9 of Diamonds';
card_names{35} = '10 of Diamonds';
card_names{36} = 'Jack of Diamonds';
card_names{37} = 'Queen of Diamonds';
card_names{38} = 'King of Diamonds';
card_names{39} = 'Ace of Diamonds';
card_names{40} = '2 of Hearts';
card_names{41} = '3 of Hearts';
card_names{42} = '4 of Hearts';
card_names{43} = '5 of Hearts';
card_names{44} = '6 of Hearts';
card_names{45} = '7 of Hearts';
card_names{46} = '8 of Hearts';
card_names{47} = '9 of Hearts';
card_names{48} = '10 of Hearts';
card_names{49} = 'Jack of Hearts';
card_names{50} = 'Queen of Hearts';
card_names{51} = 'King of Hearts';
card_names{52} = 'Ace of Hearts';
% Shuffle the deck
shuffled_deck = randperm(52);
% Ask the user for # of players and # of cards per player
clc
num_players = input('How many players? Enter here: ');
num_cards = input('How many cards per player? Enter here: ');
disp('----------------------')
% Create empty player hand arrays
for k=1:1:num_players
plyr_hnd_cmd_str = ['player_hand_',num2str(k), '= [];'];
eval(plyr_hnd_cmd_str);
end
% Deal cards out to the players
total_cards_to_deal = num_players * num_cards;
i=1;
while i < total_cards_to_deal
for j=1:1:num_players
deal_card_cmd_str = ['player_hand_', num2str(j), ' = [player_hand_',num2str(j), ', shuffled_deck(i)];'];
eval(deal_card_cmd_str);
i = i+1;
end
end
% Display each player's hand
for k=1:1:num_players
disp_plyr_str = ['Player ', num2str(k), '''s hand: '];
disp(disp_plyr_str)
for m=1:1:num_cards
card_name_cmd_str = ['card_name_str = card_names{player_hand_', num2str(k), '(m)};'];
eval(card_name_cmd_str)
disp(card_name_str)
end
disp('----------------------')
end

MATLAB Script: Best MBA Course

2014-12-19T14:11:00.001-05:00

Upon the completion of my MBA at BU, I wanted to figure out what my top 5 courses (out of 18) were.

So I wrote a brute-force, unsexy MATLAB script that did a round-robin style side-by-side comparison.

It worked out fairly well. I even put in a very rudimentary tiebreaker loop wherein the user is asked to break the tie. Basically a "head to head" comparison, which, upon further review, should be pre-determined, since the user had already done a head-to-head comparison of the two courses before. Room for improvement.

Here it is:

% Determines the ranking of best MBA courses taken

% The user picks the best course by choosing between all combinations

clc

clear

num_courses = 18;

% Create the list of courses

% Course 1: "OB 712: Managing Organizations"

course_names{1} = 'OB 712: Managing Organizations';

% Course 2: "AC 711: Accounting"

course_names{2} = 'AC 711: Accounting';

% Course 3: "MK 724: Marketing Management"

course_names{3} = 'MK 724: Marketing Management';

% Course 4: "QM 717: Statistics"

course_names{4} = 'QM 717: Statistics';

% Course 5: "FE 730: Economics"

course_names{5} = 'FE 730: Economics';

% Course 6: "IS 711: IT Strategies"

course_names{6} = 'IS 711: IT Strategies';

% Course 7: "OM 726: Operations"

course_names{7} = 'OM 726: Operations';

% Course 8: "SI 751: Strategy"

course_names{8} = 'SI 751: Strategy';

% Course 9: "PL 700: Law and Ethics"

course_names{9} = 'PL 700: Law and Ethics';

% Course 10: "ES 700: Executive Presentation"

course_names{10} = 'ES 700: Executive Presentation';

% Course 11: "OB 853: Negotiations"

course_names{11} = 'OB 853: Negotiations';

% Course 12: "OM 880: Product Design"

course_names{12} = 'OM 880: Product Design';

% Course 13: "MK 864: Pricing"

course_names{13} = 'MK 864: Pricing';

% Course 14: "MK 862: High-Tech Marketing"

course_names{14} = 'MK 862: High-Tech Marketing';

% Course 15: "IS 827: Platforms"

course_names{15} = 'IS 827: Platforms';

% Course 16: "OB 848: Leadership"

course_names{16} = 'OB 848: Leadership';

% Course 17: "MK 852: Marketing Analytics"

course_names{17} = 'MK 852: Marketing Analytics';

% Course 18: "SI 845: Technology Strategy"

course_names{18} = 'SI 845: Technology Strategy';

% ES 700 and FE 722 were not considered for ranking

% Create a 2x18 matrix of randomly determined combinations

rand_course_combs = rand_combs(num_courses);

%rand_course_combs = rand_combs2(num_courses); %Alternative algorithm that doesn't use Statistics Toolbox

len_rand_course_combs = length(rand_course_combs);

points_array = zeros(1,num_courses);

better_course = 0;

for i=1:1:len_rand_course_combs

course_1_name = char(course_names(rand_course_combs(i,1)));

course_2_name = char(course_names(rand_course_combs(i,2)));

prompt_str = [course_1_name, ' (1) vs. ',course_2_name, ' (2): '];

clc

pct_cmplt = 100*((i-1)/len_rand_course_combs);

pct_cmplt_str = [num2str(pct_cmplt), '% complete'];

disp(pct_cmplt_str)

disp('Which one was better?');

better_course = input(prompt_str);

if better_course == 1

points_array(rand_course_combs(i,1)) = points_array(rand_course_combs(i,1)) + 1;

elseif better_course == 2

points_array(rand_course_combs(i,2)) = points_array(rand_course_combs(i,2)) + 1;

end

% Sort, rank, and display

sorted_points_array = sort(points_array,'descend');

len_points_array = length(points_array);

rank_array = zeros(1,len_points_array);

i=1;

while i <= len_points_array

rank_array_temp = find(points_array == sorted_points_array(i));

if length(rank_array_temp) > 1

% Assumes only two values will be "tied". Should probably make this

% more robust.

% Break the tie by prompting user to pick the better option

disp('Found a tie!')

disp('Need to break it!')

disp('Which one was better?')

course_1_name = course_names{rank_array_temp(1)};

course_2_name = course_names{rank_array_temp(2)};

prompt_str = [course_1_name, ' (1) vs. ',course_2_name, ' (2): '];

tiebreaker_choice = input(prompt_str);

if tiebreaker_choice == 1

rank_array(i) = rank_array_temp(1);

rank_array(i+1) = rank_array_temp(2);

else

rank_array(i) = rank_array_temp(2);

rank_array(i+1) = rank_array_temp(1);

end

i=i+2;

else

rank_array(i) = find(points_array == sorted_points_array(i));

i=i+1;

end

len_rank_array = length(rank_array);

for j = 1:1:len_rank_array

clc

disp_str = [num2str(j), ': ',course_names{rank_array(j)}, ' : ',num2str(sorted_points_array(j)), ' points.'];

disp(disp_str)

end

Here were the results:

1: OM 880: Product Design : 17 points.

2: IS 827: Platforms : 16 points.

3: OB 853: Negotiations : 15 points.

4: MK 862: High-Tech Marketing : 14 points.

5: MK 852: Marketing Analytics : 13 points.

6: MK 724: Marketing Management : 12 points.

7: SI 751: Strategy : 11 points.

8: FE 730: Economics : 10 points.

9: AC 711: Accounting : 9 points.

10: SI 845: Technology Strategy : 8 points.

11: OB 712: Managing Organizations : 7 points.

12: MK 864: Pricing : 6 points.

13: ES 700: Executive Presentation : 4 points.

14: OM 726: Operations : 4 points.

15: OB 848: Leadership : 3 points.

16: IS 711: IT Strategies : 2 points.

17: QM 717: Statistics : 2 points.

18: PL 700: Law and Ethics : 0 points.

Improved Script

2014-07-03T11:45:00.000-04:00

I decided to get a little fancy with the "random PDF" script from my last post.

I modified the random selection element to be weighted based on age. I decided to start simple by simply dividing file age (in days) by 10 (I'll try using the log next), rounding up (using math.ceil) and randomly selecting from a new array (called "weighted_files") which gives more weight to older files. Basically: I want it to be more likely that an older file is opened rather than a newer file. My reading model has now shifted to a FIFO scheme.

Here it is, with a few comments.

#! /usr/bin/python
import time, os, math, sys, shutil
from random import randint
clear = lambda: os.system('cls')
clear()
path = '[DIRECTORY WITH PDF FILES IN IT]'

pdf_files = [f for f in os.listdir(path) if f.endswith('.pdf')]

len_pdf_files = len(pdf_files)
if len_pdf_files == 0:
print ("No PDF files found!")
time.sleep(3)
sys.exit(0)

pdf_ages = []

for pdf_file in pdf_files:
os.rename(os.path.join(path, pdf_file), os.path.join(path, pdf_file.replace(' ', '_')))
file_loc = path + '/' + pdf_file
file_age_sec = time.time() - os.path.getmtime(file_loc)
file_age_days = file_age_sec/60/60/24
file_age_days_round = math.floor(file_age_days)
pdf_ages.append(file_age_days_round)
# Build an array for use in weighted random selection
weighted_files = []
weighting_factor = 10 # arbitrary
for index, pdf_age in enumerate(pdf_ages):
weight = math.ceil(pdf_age/weighting_factor)

# Adds the index number (from pdf_ages, which should match pdf_files) in proportion to the weight
for i in range(0,weight):
weighted_files.append(index)

len_weighted_files = len(weighted_files)
rand_int = randint(0,len_weighted_files-1)
pdf_files_index = weighted_files[rand_int]
file_name_str = str(pdf_files[pdf_files_index])

file_loc_str = path + '/' + file_name_str
pdf_cmd_str = "start " + file_loc_str
os.system(pdf_cmd_str)
valid_command = 0
while valid_command == 0 :
delete_file = input("Delete file? Y or N: ")
if (delete_file == "Y" or delete_file == "y"):
os.remove(file_loc_str)
print (file_name_str + " has been deleted! Good work!")
new_num_pdfs = len_pdf_files - 1
new_num_pdfs_str = str(new_num_pdfs)
print ("There are now ",new_num_pdfs_str," PDFs remaining.")
time.sleep(3)
valid_command = 1
sys.exit(0)
elif (delete_file == "N" or delete_file == "n"):
print ("Fine then, but next time, delete it!")
dest_folder_loc_str = 'D:/Users/a27m8mt/Documents/Things_To_Read/Hold_for_later/'
shutil.move(file_loc_str,dest_folder_loc_str)
print (file_name_str + " has been moved to the holding folder: " + dest_folder_loc_str)
time.sleep(3)
valid_command = 1
sys.exit(0)
else:
print ("Invalid command. Try again.")

Python Script for Opening a Random PDF in a Given Directory

2014-07-01T14:07:00.002-04:00

I decided to try learning Python, so I came up with a script of nominal utility. It's probably quite ugly, but it works.

It opens a random PDF from a directory full of PDFs that I've accumulated over the past year or so of articles I've been meaning to read. At the end, it prompts the user to save or delete the file. It's quite cathartic.

If you have a similar problem, I hope this helps clean up your life a bit. Red text is where you fill in the blanks. If you're using Windows, make sure to use forward slashes for the path (e.g. 'D:/users/something/something')

import os, sys, time
from random import randint
# Clear the command window
clear = lambda: os.system('cls')
clear()
# Set the path with all of the PDF files
path = '[directory with all of the files]'
# Create a list of all of the PDF files
pdf_files = [f for f in os.listdir(path) if f.endswith('.pdf')]
# Clean up the names by removing spaces
for pdf_file in pdf_files:
os.rename(os.path.join(path, pdf_file), os.path.join(path, pdf_file.replace(' ', '_')))
len_pdf_files = len(pdf_files)
# Generate a random number
rand_int = randint(0,len_pdf_files)
# Get the name of a random PDF file
file_name_str = str(pdf_files[rand_int])
file_loc_str = path + '/' + file_name_str
# Generate a string to be used to open the file
pdf_cmd_str = "start " + file_loc_str # Windows uses "start"
# Open the file
os.system(pdf_cmd_str)
# Prompt the user to delete the file
delete_file = input("Delete file? Y or N: ")
if delete_file == "Y":
os.remove(file_loc_str)
print (file_name_str + " deleted! Good work!")
# Give the user a few seconds to read the statement
time.sleep(3)
sys.exit(0)
else:
# Chastise them for being a hoarder, while enabling them
print ("Fine then, but next time, delete it!")
time.sleep(3)
sys.exit(0)

"How The Economic Machine Works" by Ray Dalio

2013-10-31T21:23:00.001-04:00

Lovely.

TED: Michael Porter on the role of business in solving social problems

2013-10-07T13:40:00.001-04:00

Nothing really ground-breaking, but I like Porter's points.

Underground Automatic Bike Parking System

2013-09-06T17:21:00.001-04:00

Hat tip: The Atlantic

Prisoner's Dilemma Example and the Coalition Game

2013-08-08T15:54:00.003-04:00

A great example of the Prisoner's Dilemma via kottke.org

Note Nick's insistence upon picking "Steal" right away, which put Ibraham in the position of taking a serious leap of faith. I was surprised by the ending.

I actually had a similar experience last night in my Negotiations class. We played "The Coalition Game," which went like so:

Three teams (A, B, and C) discuss how to split a pot of money. The pot of money can only be split between two teams (the coalition), leaving one team out. The pot of money to be split depends on which two teams form the coalition. The pot cannot be split evenly, and neither team can accept less than $0.01.

If Team A and Team B form a coalition, they split $20.

If Team A and Team C form a coalition, they split $16.

If Team B and Team C form a coalition, they split $12.

A coalition is formed only when two teams, after 9 rounds of one-on-one negotiations (order is below), agree on how to split the pot with one other team. After the final round of discussions, each team, individually and secretly, submits a slip of paper with their perceived agreement with another team. If none of the slips match, there is no coalition, and every one walks away with nothing.

Each team negotiates with one other team at a time, with the other team outside the room.

The order of negotiations is:

(repeated twice more)

I was on Team A. We started off by offering Team B $13, with us taking $7.

We ended up outside the coalition at the end. It was a good exercise in trust and simple human greed.

The Police - "Invisible Sun"

2013-06-22T15:17:00.001-04:00

One of my favorite songs by The Police. The video is unavailable online in the U.S. RSS folks: click through if you can't see the video below.

Function Version: Determining Effective APY

2013-06-10T11:11:00.000-04:00

In case you're more into functions:

function effective_apy_midpoint = effective_APY_midpoint(P,Y,n)

% Determines the effective annual yield (APY) given a principal amount,

% a final amount, and number of years.

% Need to calculate r (APY)

% Use mid-point algorithm

% Formula is Y = P(1+r)^n

% Assume range of r from 0 to 5 (0 % to 300%)

r_min = 0;

r_max = 5;

current_guess = r_min;

Y_temp = P*(1+current_guess)^n;

num_guesses = 1;

while Y_temp ~= Y

if (Y_temp > Y*0.9999) && (Y_temp < Y*1.0001)

break

end

if Y_temp < Y

next_guess = (current_guess + r_max)/2;

else next_guess = (r_min + current_guess)/2;

end

Y_temp = P*(1+next_guess)^n;

if Y_temp < Y

r_min = next_guess;

else r_max = next_guess;

end

current_guess = next_guess;

num_guesses = num_guesses + 1;

Y_temp = P*(1+current_guess)^n;

end

effective_apy_midpoint = current_guess;

MATLAB Script: Determining Effective APY

2013-06-10T10:55:00.001-04:00

It's ugly, and I'm not sure if "midpoint algorithm" is the actual name of the algorithm. I remember doing this for my Numerical Methods course.

% Determines the effective annual yield (APY) given a principal amount,

% a final amount, and number of years.

clear

clc

P = input('Enter principal (beginning) amount: ');

Y = input('Enter final (ending) amount: ');

n = input('Enter number of years: ');

% Need to calculate r (APY)

% Use mid-point algorithm

% Formula is Y = P(1+r)^n

% Assume range of r from 0 to 5 (0 % to 300%)

r_min = 0;

r_max = 5;

current_guess = r_min;

Y_temp = P*(1+current_guess)^n;

num_guesses = 1;

tic

while Y_temp ~= Y

if (Y_temp > Y*0.9999) && (Y_temp < Y*1.0001)

break

end

if Y_temp < Y

next_guess = (current_guess + r_max)/2;

else next_guess = (r_min + current_guess)/2;

end

Y_temp = P*(1+next_guess)^n;

if Y_temp < Y

r_min = next_guess;

else r_max = next_guess;

end

current_guess = next_guess;

num_guesses = num_guesses + 1;

Y_temp = P*(1+current_guess)^n;

end

toc

r = current_guess;

effective_apy = r*100;

output_str = ['Effective APY = ',num2str(effective_apy),'%'];

num_guess_str = ['With ',num2str(num_guesses),' guesses.'];

disp(output_str)

disp(num_guess_str)

Product Idea: Restaurant-Provided Credit Card Roulette

2013-06-05T15:19:00.000-04:00

As a male in his mid 20s, I have come across the "Credit Card Roulette" phenomenon a few times. Personally, I think it's better to just alternate picking up the check, but I can see the appeal of random chance when it comes to paying for a meal.

For those unfamiliar with the game, the basic form involves all diners in a party throwing their credit cards in a hat or similar container. A random credit card is drawn from the hat, sometimes by the server to maintain objectivity, and that card is used to pay for the entire meal. Usually this game is played at the end of the meal to prevent people from ordering more food than they normally would if they were paying for it themselves.

But that particular moral hazard got me thinking: what if restaurants provided a system that would let patrons play Credit Card Roulette before the meal began in exchange for a 10% discount off the entire meal? The restaurant would stand to gain, of course, if non-paying diners ordered more than 10% of what they would normally order.

I'm sure some clever game designer could figure out exactly what the interface to diners would be (kiosk at the table, smartphone app, etc.), but the concept would cater well to the gambling culture in America.

Benefits:

- At worst, the losing player would be treating their friends or colleagues to a meal they enjoyed. And most gamblers just like the adrenaline rush, right?

- Payment would be easier and faster if it's all going on one card (good for diners and the restaurant).

- Losing diners would be encouraged to return, thinking they wouldn't have to pay again because of the general misunderstanding of probability (see: the lottery). That's good for the restaurant.

Nobody really loses.

2013 Monaco Grand Prix Finishing Position vs. 2013 Driver Salary

2013-05-28T15:41:00.001-04:00

I've only watched a few Formula One races, but I did manage to catch this weekend's Grand Prix de Monaco. Beautiful and exciting race, and only about 100 minutes long for those with things to do.

I did a quick regression on finishing position vs. 2013 driver salary. It's only one race, so there's bound to be some discrepancies (there were a couple accidents and one engine fire). However, the correlation is still quite moderate (R=0.613) andit makes the case for a more egalitarian approach to driver salaries. Alas: there's more to racing than just one race, and more to racing than, well: racing.

To note: one would expect a fairly strong downward-sloping curve if drivers were paid based on the results of just this one race.

I'll do another regression on 2013 World Series final results vs. salary.

Salary data (via Reddit) courtesy of Crash.net.

And when you log the salaries:

The best fit, as one may expect, is exponential:

Great Aerial Footage of San Francisco

2013-04-06T09:28:00.000-04:00

From The Atlantic.

Video: A Case for Open Data in Transit

2013-02-17T15:17:00.002-05:00

As a user of open data from the MBTA (I'm a big fan of NextBus), I can't agree more with the movement towards opening as much data as possible to developers for urban transit initiatives. If done right, it encourages expanded ridership and can serve to make the services more efficient.

I think O'Reilly's point in the video of government serving as a platform for private development is startlingly obvious and insightful.

The Restaurant Service Auction Market

2013-02-09T21:15:00.002-05:00

A recent story about a cheap pastor in St. Louis who got an Applebee’s server fired for uploading a copy of the pastor’s receipt (the pastor didn’t like the mandatory 18% tip for a group of 6, so she stiffed the server citing religious reasons) got me thinking about the Principal-Agent Problem again. I won’t dwell on it too much, but two quick things:

First off, the obvious: doesn’t 10% seem a little low for a pastor? Why bother giving that figure, anyway?

Secondly, punishing the server for a (disclosed and commonly applied) mandatory tip is a textbook example of the perils of the Principal-Agent Problem in the food service industry. The pastor should have gone directly to the manager to complain about the policy, but decided to take it out on the lowly server.

The fact that a religious figure was involved is a large part of why this story got out, but the fact of the matter is: the pastor should have taken out her frustration in another manner. It’s not like people blame her for bad weather events (a.k.a. Acts of God), right?

Anyway, this sort of customer behavior can be avoided through a market approach. That is why, if I were to open a restaurant, I’d try something like this:

All tips are set at a minimum of 15% and are pooled among all restaurant staff and there is no cap (i.e. a customer could bid for a 100% tip if they so desired)
Additional preferred treatment can be arranged by bidding (in units of % of the bill as total tip), such as:

Personal food/drink recommendations

Faster service (this would be automatically controlled by the kitchen and bar – servers may game the system by holding up orders to appear like service to other tables is faster; customers can bid on when their meals or drinks come out)

The estimated time of arrival of the meal or drink must be known to the customer for transparency.

Requests for special occasions (birthdays, engagements, etc.)

Customers are held to their promised tip amount unless the promised service at the time of the bid is not met (e.g. the food arrives a few minutes late)
The price for a “bid for preferential treatment” is based on supply and demand. For instance, if it’s a busy Friday night with lots of people bidding, a 1% increase in tip won’t get you to the top of the list.

Customers would only know if there is someone ahead of them and will be told by the system the current price (in % of tip) of a bid for a given request
Someone who does not bid must be guaranteed some reasonable level of service. You might think of this as the “floor.”

Standard quality must be maintained no matter how "rushed" a customer wants their food. This gets tricky if people want their food to be cooked faster than good quality would allow. This would need to be factored into resource constraints when telling the customer how quickly the food can be delivered to their table.

I'm not sure how well it would work (i.e. how long I'd stay in business), but it would be a good dining experiment.

Data Crunching, Election Edition

2012-11-09T15:34:00.000-05:00

I'm getting more into data analytics, and have been looking for some substantial examples beyond the usual "more and more companies are using analytics" blanket statements from Harvard Business Review. Much to my relief, Time came out with a nice piece about the Obama campaign's use of data in their recent electoral victory.

Full disclosure: I'm a libertarian and was in the 1% of the population that voted for Gary Johnson. Living in Massachusetts, my vote didn't matter anyway. I also voted for Scott Brown for Senate because he is a moderate, though his campaign was poorly managed.

Anyway, the article points out some interesting bits about how the Obama campaign pulled off the win. Through massive computer simulations, data crunching, targeted ads, and efficient door-knocking, they were able to raise $1 billion. That is impressive no matter how you spin it, folks. One can only imagine what upcoming local elections will have.

I have a friend who works in the (spinning down post-election) Elizabeth Warren campaign. He's more on the database-building-mechanics side of things, but he was able to talk about how the campaign used the data to target individual voters. My bet: the scale of analytics used in this year's national election (per voter) will be used at the local level in 2-4 years.

Delivery Time Improvement Auction Market

2012-11-05T09:18:00.000-05:00

In high school and during college breaks, I worked at a local pizza place (as I've mentioned all too frequently here). As an overzealous engineering student, I was always looking for ways to do things more efficiently. One of our biggest problems: inefficient allocation of human capital (a.k.a. delivery boys).

Alas, I never had the time to come up with anything fancy, until now (years later). I decided to start a pet project to develop a web-based "Pizza Delivery Route Optimizer" using as much open source software as possible.

I'm still designing the system, and don't plan on selling it, but a thought occurred to me:

What if people could bid in a live auction on how quickly their orders could arrive? Let's say it's a busy Friday night, and you want your pizza there in 30 minutes or less. In a fair world, even with a fancy Pizza Delivery Route Optimizer running, this would be an unrealistic expectation.

But what if it weren't? What if you could see approximately when your order would arrive, how many orders were ahead of you, and could either bid against other orders to move up in the pecking order or pay a small fee to do the same? What would be a fair price? I'd imagine it would be tailored to current supply (number of drivers) and demand (number of orders). For example, if there are 20 orders ahead of you and only 15 drivers on staff, the fee would be higher than it would be if there were 10 orders and 12 drivers.

To do an auction, the customer would need to set up an account and would only be billed if their expected (not actual) delivery time were made earlier. It'd be unfair to the delivery guy (and probably unsafe) to guarantee a time of arrival. Remember Domino's "30 Minute Guarantee"? Domino's ended it when a delivery guy killed someone trying to make it in the 30 minute window.

I think there may be a market for the auction format, but the implementation would be tough. For one, you wouldn't likely have people stay on a website to actually bid in real time (they are, after all, not willing to spend the time picking the pizza up in the first place). Therefore, a simple fee would probably be easier to implement. This would, however, not necessarily do well for the delivery guy, since the customer would feel no reason to tip the delivery guy if they've already paid more for the delivery in the first place. Perhaps you could split the fee with the delivery guy? It's a tough one to do if you want things to be fair to all parties.

2012 MLB Dollars Per Win

2012-10-29T09:42:00.001-04:00

With the San Francisco Giants' sweep of the Detroit Tigers last night, the 2012 MLB Season is officially in the books.

As I've done the past few years, I broke things down in simple terms: which teams were the most efficient in getting the most value per dollar in payroll? Yes, this isn't really a straightforward answer, since teams with higher payrolls tend to have higher non-baseball revenues (namely merchandising and TV deals), but from a pure baseball standpoint: who had the best year?

Below is a simple table of how teams ended up in terms of dollars in payroll vs. total wins (including post-season). The Oakland Athletics, a perennially efficient team, did extremely well this year, spending nearly one fifth as much per win as the lowly Red Sox. Not to be forgotten was the sub-par performance of the Phillies this season.

Source for payroll amounts: http://www.cbssports.com/mlb/salaries

The World Series Champion San Francisco Giants ended up in the middle of the pack due to their above average payroll, though one could argue winning it all is worth it. I would also credit the Washington Nationals for being the only other 100 win team while having a below average payroll; great year for the Natinals.

Just for your edification, here is the correlation between wins and payroll this year. Note how low R^2 is: 0.053. I'd have to look at other years, but this year turned out to be quite a year of parity.

Nissan's New "Steer By Wire" Technology

2012-10-20T16:06:00.001-04:00

Before watching the video, I wasn't sure what Nissan was trying to accomplish. I didn't know of any market demand for this technology. After viewing the video and learning of the "smooth ride" capabilities, I was hooked. I can't wait for this to arrive in all cars.

I'm assuming the clutch also serves as the mechanical back-up in the event of a loss of power to the control units; the video seems to state that. That would be a major concern from a safety standpoint.

This also plays right into my dream of driverless cars. With this new system, all you'd need to do to make the vehicle driverless (assuming you completely remove the human driver) is ditch the steering wheel and clutch and plug the control unit into a master vehicle controller, which would also control throttle and brake. No more goofy actuators on the steering wheel; full-authority steering!

Pizza Delivery Routing Algorithm - A Pet Project

2012-10-08T10:48:00.000-04:00

A couple months ago I realized that I had completely given up on my interest in web application development. I'd studied it briefly towards the end of my Master's curriculum a couple years ago, and had been meaning to reignite my interest through a couple projects. I'm not very gifted at web development, but I've seen enough to become interested. Alas, starting an MBA and getting married became greater (and worthwhile) time sinks.

The good news (for me and my interest) is that my wedding is on Saturday, which means I'll have some free time coming up. That, and I'm most of the way through the core MBA curriculum. Right now I'm taking a course in information systems management, which, if anything, is feeding my interest in restarting my hobby. My buddy Sam has been working on something for a couple years now, and his advice was simple: "Just do something, anything. Keep sharp."

My first project: pizza delivery routing algorithm. As I've mentioned before here, I used to deliver pizzas in high school and during college breaks. I developed a strange passion for operational efficiency after the business expanded and we had a new Point of Sale (POS) system installed. This was in 2004. My boss had no interest in even developing a website for the business at the time. He was mostly concerned with building the business one week at a time. But that didn't stop me from analyzing how inefficient some of our processes were - I was an engineering student, after all.

One of the major annoyances in operating a business with a personal delivery component (e.g. pizza) is figuring out how best to allocate your delivery resources (e.g. the drivers). My boss was notorious for taking guys off the clock if business was slow. The drivers figured this out quickly and gamed the system by taking as long as reasonably possible to complete a delivery during the slow down periods. It infuriated the boss, but he had to live with it.

On the flip side, when business was booming (e.g. during the dinner rush on a Friday night), we couldn't have enough drivers. Orders would run late because of the sheer backlog. Guys would make 2-3 trips per hour. Even with 15 drivers on the clock at once, we couldn't keep up. Drivers were motivated mostly by tips, and knew that getting the order to the customer sooner rather than later would result in a better tip. Drivers couldn't care less if the next order was late. This led to serious inefficiency. Whenever I was in charge of routing deliveries, I'd have guys wait a few agonizing minutes for any deliveries they could take in tandem based on geographical proximity - basically: if you have two orders going to Main Street in Trumbull (a 15 minute drive), have the driver take both even if they came in 10 minutes apart. It drove drivers, and my boss, crazy, but it resulted in fewer late orders on the whole. We would call these "two baggers" or "three baggers" - depending on how many orders went out (in warming bags).

I wished that the manual routing I had to do were somehow automated. I know there has to be something already out there now, but I figured my first project would be to develop something simple.

The interface should be straightforward: provide the user (e.g. manager) with a table of all open delivery orders grouped by recommended batch. A batch would be determined based on driving time for the round trip and would be temporal - you wouldn't batch two orders together that were ordered more than 35 minutes apart (for argument's sake). The idea is to provide the manager with a set of options to maximize the efficiency of each delivery driver at any one time.

The system would have to be flexible and optional. It would have to interface with the existing POS system to collect all open orders coming in. It should be optional because of various factors that come into play, especially driver skill. A manager probably wouldn't want to assign a long and expensive "three bagger" to the newest driver. The manager would have the option to break the orders into pieces. Therefore, the system would have the be "slave" to the POS system except, perhaps, if the manager decided to go with the recommendation and assign deliveries through it and have the POS system only become the "slave" in such cases. For example, if the system recommends a particular batch, the manager would select that batch, match it with a driver, and click "ASSIGN." The system would send the request to the POS system, which would assign those three orders to the driver.

I plan on using the MapQuest API for the background routing algorithm. There are many other options, but I found MapQuest's to be the most open for now.

There are a few tricky aspects that I'll need to take into account:

- Ensuring the correct address is entered. This would probably need to be tied in with the POS - the user may need to confirm the address with the customer.
- Tweaking the interface with the POS system to pull and push requests (timing, etc.). I'll have to make my own dummy POS for starters.
- Tweaking the algorithm to take other factors into account, like weather (doubtful) and performance parameters for drivers like average delivery time (maybe)

I doubt any business would actually pay for this, but it's a neat project. Maybe, just maybe, I could get a blurb in Pizza Today.

The CN Turbo Train

2012-10-02T21:11:00.001-04:00

Canadian rail was way ahead of its time.

The TurboTrain - a United Aircraft product.

Customer Service and the Principal-Agent Problem

2012-09-30T09:52:00.000-04:00

A couple weeks ago, I read a nice little piece that Stephen Dubner wrote on the Freakonomics blog about the principal-agent problem. A cheap, but guilt-ridden, reader wrote in to Freakonomics about an unfortunate transaction involving a cab ride in Las Vegas. The reader was charged $3 to use his credit card on a fare of $11.50, and decided to take it out on the cab driver, who was nonplussed and berate.

This is a familiar story to anyone in the food service industry, let alone anyone who works in customer service. Anyone who has had to deal with unruly customers who feel “cheated” by something, like a late delivery of their food, usually takes it out on the easiest target (pizza delivery guy, cashier, whomever) instead of those truly responsible for the wrong-doing (manager or store owner). In reality, the principal (the store owner) usually has the leverage (pizza delivery guys are usually just happy to be working) and would rather the customer take out their frustration on the messenger in most cases.

It has to do with misaligned incentives. Back in high school and during college term breaks, I worked at a pizza place that offered “fast free delivery.” My fellow drivers and I made most of our money (our wages were low – I left the place earning $7.50 an hour after starting at $5) through tips. The business benefitted from customers who were attracted to the “free” aspect of the delivery service. The rationale we were given as drivers was that the customers would tip us more than we would have received from a delivery fee. For the most part, this was true, and drivers benefitted from the “free delivery” protocol, but it didn’t shield us from dealing with disgruntled, and frequently rude, customers. Despite the root cause usually being out of the driver’s control (busy night, a mistake in the kitchen, etc.), customers usually exerted punishment on the drivers through reduced (or nonexistent) tips.

One approach I took was to grease the wheels a bit when I knew a fellow driver was going to take a hit for something like a delivery that left the store late (I’d usually wait a few minutes to give the driver some breathing room). While waiting for an order to take, I would call the customer and inform them that we’d been flooded with orders and the driver had just left. I can’t remember many times, save for perhaps a couple exceptions with some truly rude customers, when this didn’t benefit the driver. He’d arrive and be greeted by an understanding customer and the tip amount would usually be unaffected (sometimes it would be higher than expected!). My boss didn’t agree with this strategy because “it makes us look bad if we're slow,” but I continued the “honesty first” approach nonetheless because it didn't really affect the owner's bottom line since the food wasn't going to get there any faster if I called ahead or not.

Another approach, which got me in trouble a couple times, was only employed if I was the driver who arrived to a late order. If the customer complained and tipped poorly, I’d apologize and inform them of the following:

“Thank you for your business. I understand your concern, and would like to inform you that the free delivery service is not your only option in obtaining your order. Pick-up is always an option.”

One customer was visibly upset when I gave him such a disclaimer, and followed me back to the store to complain to the manager on duty. He approached the counter and loudly asked the girl behind the register to find the manager on duty. She looked over at me (the manager on duty) and said “Pat, this gentleman would like to speak to you.” I think the conversation lasted about a minute before he apologized for losing his head. I gave him a menu and told him to keep it handy if he felt like picking up a pizza from us again (words carefully chosen). It’s all about aligning incentives, folks.

"Psycho Killer" - The Ukulele Orchestra of Great Britain

2012-09-10T22:40:00.000-04:00

Cooking Simulator

2012-08-29T17:46:00.000-04:00

Try as I might, I cannot find the utility.