Ideally, the firm would really want to keep the same level of employees (assuming all other things are constant). Before the inflation occurred, the firm was presumably at an employment level equilibrium maximizing profit (marginal product of labor was 0). If wages could somehow be “inflation-indexed” during times of deflation without the psychological effect of a wage cut, the firm might have a more efficient outcome.

I think one way that you see firms trying to do this is through bonus systems. It’s common for executives to have bonuses contingent on the nominal company performance (which will correlate with deflation), which in a way is sort of inflation-indexing. According to a friend of mine working at Royal Dutch Shell (aka Shell Oil), bonuses are based on both performance reviews and company performance. At Microsoft, bonuses are primarily based on performance, but I would not be surprised if adjustments to the bonus schedules are based on economic conditions.

It’d be nice if we could make wages less sticky while avoiding the psychological effects of a wage cut…

Given a 64-bit integer, what is the fastest way to reverse the ordering of the bits? The naive approach is to use a loop getting 1 bit into place each iteration. The result is something like this:

private static ulong RevBits1(ulong p)
{
ulong r = 0;
for (int i = 0; i < 64; i++)
{
r = r >> 1;
r = r | (p & 0x8000000000000000);
p = p << 1;
}
return r;
}

If you don’t count the loop operations, this ends up with 256 operations, 4 per iteration. If you unroll this, you can make one of the terms a constant factor, bringing the operation count down to 192. We can improve on this with a divide and conquer approach:

private static ulong RevBits(ulong p)
{
p = (p << 32) | (p >> 32);
p = ((p << 16) & 0xFFFF0000FFFF0000) | ((p >> 16) & 0x0000FFFF0000FFFF);
p = ((p << 8 ) & 0xFF00FF00FF00FF00) | ((p >> 8 ) & 0x00FF00FF00FF00FF);
p = ((p << 4) & 0xF0F0F0F0F0F0F0F0) | ((p >> 4) & 0x0F0F0F0F0F0F0F0F);
p = ((p << 2) & 0xCCCCCCCCCCCCCCCC) | ((p >> 2) & 0x3333333333333333);
p = ((p << 1) & 0xAAAAAAAAAAAAAAAA) | ((p >> 1) & 0x5555555555555555);
return p;
}
Harder to read, but this version is only 28 operations. In asm we could get this down even farther on 64 bit machines, since the first statement can be written as a 32 bit rotation, and the second statement can be written as two 16 bit rotations, bringing our operation count down to 24. Since each of our other operations is nearly equivalent to an opcode (on 64-bit processors at least) this is pretty close to the actual number of opcodes that could be generated by a good optimizing compiler.

It would be interesting to see if this could be optimized further

-Tim

Not necessarily. A recent slate article examines the discrepancy between black and white spending on “visible goods” (like fancy clothes, luxury car, etc). The proposed explanation is that black people tend to live in neighborhoods of other black people of relatively similar income levels (compared to that of white people). The increased spending on visible goods has nothing to do with race, but simply a result of increased tendency for “signaling”. The net result of “signaling” is that more money is spent on “visible goods” and less is spent on health care and education.

Does this mean that equality is bad? Probably not, however it certainly means there are significant unintended consequences that are highly unintuitive.

http://pages.cs.wisc.edu/~driscoll/misc/aqsis_mystery/

Bill Gates is my personal hero, which should come as no surprise to those who know me as a Kool-Aid drinking fanboy. However, the reason I admire Bill Gates has little to do with Microsoft itself. He exemplifies personal qualities that I admire, including technical breadth, ambition, and commitment to effective philanthropy. I’m sure Bill has made some mistakes over the years, as many would like to point out, but the way I see it, the best way to judge character is to see if a person really puts his money where his mouth is. Bill delivers, though I suppose that makes his mouth pretty big.

Adios, billg! So long, and thanks for all the fish/DOS/qbasic/etc.

-Tim

IE8 passes ACID2!

Everyone is excited about the newest generation of consoles. Microsoft is going all out with XBox 360, and Playstation 3 will doubtless be amazing. The underdog, in this generation of consoles, will be the Nintendo Revolution. Or will it?

XBox 360 costs $399 (The core system doesnt exist, so dont talk to me about that). Rumor has it that PS3 will cost upwards of $499 (Although I think a price point of $399 will make it much more competitive with XBox). And how much does the Revolution cost? Probably around $150. It’s no secret that Nintendo doesn’t want to compete with Sony or Microsoft. Who can blame them? Nintendo follows no one’s rules but their own. Nintendo is not getting sucked into the console arm’s race for the most spectacular graphics. It’s fairly likely that the Nintendo Revolution will have graphics only marginally better than the original XBox.

I still put my money on Nintendo. In fact, I don’t know for sure whether PS3 will win over 360, or vice versa, but I do know that Nintendo Revolution will do just fine, regardless of what happens to the other consoles.

Nintendo has always been an innovator. This has been the key to their success, and has also been the cause of many laughable failures. They have a philsophy that seems to be willing to try anything. Products such as Virtual Boy, Nintendo DS

I can’t decide if I was psychic, good at picking up industry activity, or if this was obvious. To this day, it’s hard to find a Wii because every console is sold out.

For what it’s worth, my money is on Silverlight. When Microsoft announced that Silverlight applications will use CLR, and that CLR will be available on OSX, my jaw dropped. The ability to write a rich internet application using the amazing power of C# and the Common Language Runtime is amazing, and the fact that this will work on OSX shows that MS is serious about making this a viable platform. On top of this, I’m sure that there is going to be an extremely intuitive RPC mechanism to interact with ASP.Net webservices (and PHP/Ruby/etc. webservices). The boost in developer productivity is going to have a direct impact on the quality of applications that will be developed in the next few years.