Capital Gains Tax Rates and Antisemitism

2012 April 17 10:55 AM

It started when a friend of mine asked the question:

Question for those more financially savvy than I am: what is the economic logic behind taxing capital gains at a lower rate than regular income? It seems like the lower tax rate is intended to foster economic growth by encouraging investors to hold onto the asset(s) in question for longer, thus reducing market churn and encouraging long-term investment. Is that the sole reason?

What disturbed me about the ensuing discussion is a sentiment that comes up frequently when discussing Wall Street, “speculation”, high-frequency trading, banking, and just about any other finance related activity, industry, and profession.

One person expressed it this way:

Today [the capital gains tax rate] is also applied to short sells and other casino-like behavior where the asset is bought and resold in a matter of days or even hours and there is absolutely no justification for that.

Another person said it like this:

If you take money you have saved and invest it in a new company, like a VC investing in a new technology startup, this actually creates new jobs. This money should be taxed differently than plunking money down long term on something like…betting oil futures rise in the next year.

The problem is that our tax law treats the two the same. One reinvests capital into the economy to create jobs (good) the other shuffles it around (usually with insider information) to make sure that gains outpace infaltion. The other side effect of investing like this is that it ties capital up in a way that ensures no new jobs get created (bad).

For thousands of years, people have displayed open hostility to those who make money through finance. This has most frequently manifested itself through antisemitism and marxist anticapitalism, resulting in the murder of tens of millions across the globe.

Murder is out of fashion now, so it’s popular to advocate that certain undesirable individuals/professions be taxed to death. But the thinking is the same: if we could just stop certain people from trading in a certain way, all our economic woes would go away. History shows that this has never worked. And there is no reason to believe it ever will work.

Just because you don’t understand something doesn’t mean it doesn’t provide a ton of value. And just because you can’t see the effects of a policy or course of action doesn’t mean there aren’t any.

Anyway, here is my response to the original question:

  1. Encourage investment. The lower the tax rate, the lower the returns need to be for a given investment to make sense. Warren Buffet has talked extensively about this.

    Thus the ideal capital gains tax rate is zero, which would lead to significant job creation over time (with the caveat of point number 5 below). This means that it is entirely plausible that a zero capital gains rate would actually increase total government tax receipts as a result of income taxes on new jobs.

  2. Avoid multiple taxation. In order to make investment income, all of these things must happens: a person must make money (which is taxed), invest that money in a corporation, the corporation must make money (which is taxed), the corporation must issue dividends to the individual (which is taxed). Thus, capital gains taxes actually represent triple taxation. Some will say this is fair because a small portion of people in this country have never worked and should pay through the nose. But it’s unfair to the overwhelming majority of people - think anyone who is on the verge of retirement and has dutifully contributed to retirement accounts for decades.

    In a very narrow set of circumstances, the second tax (corporate tax) can be avoided, but that is very uncommon and not relevant to the original question.

  3. Inflation. Lets say you invested $1,000 in Microsoft 10 years ago at about ~$25/share and you sold it today ~$31 for a total of $1240. Unfortunately, you just lost money because of inflation - according to the BLS , $1000 ten years ago is the same as $1275 today, resulting in a de fact loss of $35. Even more unfortunate, the federal government doesn’t care - you pay 15% tax on the raw $240 “profit”. This results in increasing your loss from $35 to $71.

    It is easy to imagine situations where the capital gains tax could turn even a modest real gain into a real loss.

  4. Capital gains disproportionately hurts seniors. Young people typically have very little investment income, but they can work long and hard and make money. Old people can’t and have to rely on whatever provision they made earlier in their lives.

  5. All of that said, it doesn’t really matter in terms of institutional investment. There is an enormous body of work showing that temporary, whether actually temporary or perceived transience due to political volatility, tax rate cuts have almost no impact on invest decision making. Our current political/economic environment, where raising the capital gains tax is even merely discussed, is enough to massively deter investment. The only way to stimulate investment is through credibly permanent tax cuts.

Comments

Do Not Use Go for 32bit Development

2012 April 08 10:48 AM

I’m sitting here rewriting a ton of Go code in C. And I can’t bill for the time. As the principle programmer, the buck stops here. I talked to my client and took responsibility. My mistake was trusting Go. I should have remembered my motto, stolen from the Royal Society: nullius in verba.

Despite the 1.0 release announcement of Go, I must emphatically state that if 32bit support is a hard requirement for your development, Go is not a viable option.

There are a number of bugs in 32bit Go, but the real show stopper is this:

At runtime init, Go programs attempt to reserve 512mb of virtual address space. If they can’t do this, they crash. Go needs the space because it is garbage collected - presumably, all GC languages, or any program that takes a similar approach to memory management, will be susceptible to the same problem. On 32bit Windows machines, processes only have access to 2GB user space memory. This user space can become fragmented (say, a linked DLL is loaded by the system before the 512mb allocation occurs), preventing the Go runtime from reserving its arena.

Go expects one large allocated block. I assume that other GC runtimes implement an algorithm to deal with this problem by requesting smaller chunks of memory.

The problem is hard to replicate and test - most of the time, Go programs run perfectly fine. I speculate that rebooting the machine might help solve the problem. I also speculate that only Windows is susceptible - I’ve had no bug reports about the linux version of my code. The Go devs are aware of the issue, but have designated it as low priority.

I love programming in Go. And I agree with Rob Pike that programmers complain too much when they should be fixing the problem instead. Unfortunately, I am not familiar enough with the Go runtime code to dive and make the required changes with confidence that I have both actually fixed the problem and not introduced bugs into the memory management code. I don’t have time before my deadline to look into the issue either. I will certainly look into fixing the problem once I have some spare time.

Edit: I would like to point out that the Go devs have been very helpful in diagnosing the issue. Unfortunately, their resolution always boils down to “Switch to 64bit”.

Edit: The original article states that Go tries to reserve 512mb of RAM. This is incorrect: it tries to reserve 512mb of virtual address space.

Edit: More comments on hacker news

Comments

Economics for Programmers - Backward Bending Supply Curve of Labor

2012 January 03 03:58 PM

Lets take a look at the backward bending supply curve of labor from a programmer’s perspective. For individuals, this is one of the single most important concepts in microeconomics. It explains why people are willing to work insane hours in the early part of their lives, but relatively little as they grow older. If you ever wondered why Fortune 500 CEOs make so much money, this will explain most of it.

The Algorithm

Here is how I would illustrate the backward bending supply curve of labor with code:

//starting conditions
time = START_OF_ADULT_LIFE
net_worth = BROKE
productivity = INCOMPETENT

//the days of our lives
while(time++ < LIFE_SPAN)
	income = CurrentMarketPriceForLabor(productivity)
	if(MarginalUtility(income) > MarginalUtility(personal_time))
		DoWork()
		net_worth += income
		productivity += AdjustProducitivityForIncreasingSkill()
	else if(OfferedAboveMarketIncome()) 
		if(MarginalUtility(above_market_income) >
			MarginalUtility(personal_time))
			DoWork()
			net_worth += income
			productivity +=
				AdjustProductivityForIncreasingSkill()
	else
		net_worth -= DoPersonalTime()

//rational thoughts
MarginalUtility(income) =
	Utility(net_worth + income) - Utility(net_worth)
MarginalUtility(personal_time)
	Utility(net_worth + DollarValue(personal_time)) -
	Utility(net_worth)
DollarValue(personal_time) =
	//this should probably be further adjusted to value personal
	//time over work as time approaches LIFE_SPAN
	net_worth / DESIRED_NET_WORTH * MAXIMUM_PERSONAL_TIME_VALUE

What it means

Notes

Comments

Pay Your Programmers $200/hour

2011 December 30 05:42 PM

Update: more comments on reddit and hacker news.

If you are hiring programmers, you should pay them $200/hr. This breaks through otherwise impenetrable psychological barriers, helps solve the agency problem, and ensures you are only hiring programmers when you really need them.

Expectations

$200/hr is an open declaration of your expectations. It states that you are expecting to hire both a professional and an expert in the field.

As a programmer, I treat contracts that pay me $200/hr differently from jobs/contracts that pay me $65/hr equivalent salary in two key ways. First, I treat issues and requests with far greater urgency. I’ve been on vacation when a call comes in, the customer requesting a new feature. I will go back to my hotel room immediately and build it; the high rate means its easy to justify this to my spouse - in fact, she totally supports it. I would simply never consider behaving this way under normal job conditions, because its not worth it. The worst that might happen is I lose my job, but there are a glut of $65/hr jobs available.

Second, and really this is a huge benefit to the employer, I generally do not charge for what I consider to be “learning” time. If you pay me $200/hr, I will only charge for the amount of hours that I believe an expert in the field might charge. I expect, with some variation in degrees, most programmers will behave this way. For example, I was given a project that involved coding a ton of low level C. I hadn’t coded any C in a decade. I spent two 16 hour days getting my c legs back, but I did not charge the client at all for this. I also did not charge for any bugs that I felt an experienced systems programmer would not have made. Overall, this had the effect of roughly halving the number of hours I billed.

Loyalty

But guess what? I didn’t resent the client at all. In fact, I was delighted and so were they. I got to ramp up on some rusty skills and know they value my work, and they got a product that met all their needs, on-time and on-budget.

And the next time my client needs something? They shoot right to the top of my priority list. And they benefit from an even faster and higher quality turn around, because I only need to brush up on C once, I don’t repeat the same mistakes, and I learn more about their business and the types of features they need but may not know to ask for.

You also never need to worry about the programmer leaving you. If you have a ton of work to send their way, they will do it and pocket huge surpluses on their labor. If you can only send them a few hours per week, they will still be able to live comfortably and enjoy their free time. Its win-win for contractor and client.

On a political note, high pay correlating with high expertise is more true among programmers than other professions, like lawyers and doctors, because the only reason other professions routinely charge higher rates is because they have artificially constricted supply through licensure requirements - you are effectively coerced into paying a high rate. But when you pay a programmer a high rate, there is no element of coercion whatsoever. This recognition of value is big loyalty booster all by itself.

Trust

For the employer, trust is less of a problem when you pay a high rate on contract. If the programmer doesn’t deliver, fire them. If they deliver low quality goods and don’t fix it, fire them. If you are unhappy for any reason at all, fire them.

With a lower paid programmer, its much harder to justify rapid firing. You might be tempted to do a cost/benefit analysis - maybe you suspect that programmer is slacking, but you still feel you get a good bit of work out of them. This is a fatal error. First, there is no other market on the planet where the information asymmetry between vendor and client is greater. The programmer can spin any tale they want, and you will have absolutely no way to dispute their claims. Second, ineffective or disaffected programmers are not just zeros, they are are negatives. Really big negatives that damage your business.

Optimal Resource Allocation

If you cannot afford $200/hr, you should not be hiring programmers because you are working on a problem that addresses an insufficiently large market.

Which situation would your rather be in: risking $100,000 investment for a $200,000 return, or risking $1,000,000 investment for a $50,000,000 return? This might seem like a self-answering question, but virtually all programming hires fall into the first category. Nearly every IT department and most businesses are focused on the wrong class of problems. And the problem is that this is a gross misallocation of resources, because there are tons of opportunities in the second category.

When you focus on a problem in the second category, a lot of silly business problems go away. Super tight controls on payroll and expenses are no longer needed. Schedule slips are less of a problem and less likely to occur. Morale improves from working on a big, important problem.

On the other hand, when you are in situation where paying a programmer $75 instead of $65 would destroy the economic justification for the hire, you are in an extremely fragile state. All the problems above are exacerbated and you are one micro-economic shift away from bankruptcy or irrelevance.

Comments

I Just Ordered a Ladle from Amazon

2011 December 29 11:02 PM

I just ordered a ladle from amazon.

I looked at a few different ladles.

And started reading ladle reviews.

Actual reviews that real people wrote about ladles.

And thats when I realized the internet really has changed everything.

And then I stopped reading the reviews and just ordered the least expensive ladle.

Because what the hell is wrong with me that I am reading ladle reviews?

Update: more comments on hacker news

Comments