fling93 loves fishies

Microsoft and Bundling

There’s been some discussion of bundling and Microsoft lately. Some of it is really interesting and eye-opening, but I thought I’d clear up some misconceptions myself. Warning, this is pretty long.

Bundling as Price Discrimination

First off, Tyler Cowen at Marginal Revolution has a really clear explanation of the bundling issue, explaining how it’s a form of price discrimination but that its effects aren’t as pernicious as people seem to think. For example cable stations are always bundled in a package that always includes channels you like as well as ones you don’t. What’s going on?

Consider a simple example with two individuals. John values Disney at $100 a year and FoxNews at $10 a year; Sally has the reverse valuations. Without bundling, the cable company will offer each channel for about $99, and sell a channel to each consumer, reaping $198 in revenue…

In lieu of this set up, sell the bundle for $109 to each consumer, reaping a greater revenue of $218. The company makes greater profit.

More importantly, aggregate welfare is higher. In this case each consumer receives two channels instead of one.

It might not seem obvious why aggregate welfare is higher, since you don’t have the option of buying one channel at $99 and using the saved $10 on something that would get you more utility than the extra channel.

Buy-one-get-one-free

To make it clear, consider the post of his co-blogger, Alex Tabarrok, on a different form of price discrimination and bundling, the buy-one-get-one-free promotion, which is actually quite a similar case.

…assume that you value your first pizza of the night at $15.01 and the second at $5.01 and let’s say it costs the store $2 to make each pizza. If the pizza store has a buy-one-get-one-free offer at $20 then you will buy two pizzas and the store will have profits of $16 ($20-$2-$2). But if the store sells pizzas for half price, $10 each, you will buy just one pizza and the store will have profits of just $8 ($10-$2). The BOGO doubles the store’s profits!

Carefully designed BOGOs increase profits because they let the firm price more flexibly, what economists unfortunately call “price discrimination.” At $20, the BOGO is equivalent to charging $15 for the first pizza and $5 for the second. Notice that these prices are ideal for the firm since they are the maximum the consumer will pay - any more and the consumer won’t buy.

Although BOGOs may make consumers worse off they generally increase total welfare because the price on the last unit sold is pushed closer to marginal cost and because of this output expands.

Emphasis mine, and it’s the key point to remember. The consumer is not getting cheated here. Remember, the firm still has to sell the bundle at a price less than the consumer is willing to pay for it or else the consumer passes up the deal altogether. Note in the example, you value the two pizzas at $20.02 and still come out ahead. Not as far ahead as you would have if you just bought one and spent the savings on something else where you get more utility. But because they sell more units, they are able to produce more units, which benefits everybody who wants them.

Higher output is the key advantage of capitalism. Capitalism’s strength is that it’s the most efficient way we know to allocate resources so that there is an abundance of goods at low costs, and hardly any wasted goods that go unused. This is one reason that WalMart’s effect on our society isn’t so clear cut as many liberals would have you believe. Their low costs help a lot of poor people enjoy a higher standard of living.

Why Microsoft’s Bundling is Different

Along similar lines, Arnold Kling has a pretty good essay about how widespread bundling is, and how outlawing it would likely make things worse. However, he made a comparison I thought was flawed:

The Europeans recently decided that Microsoft is not allowed to bundle a media player with its software, although nobody stops automobile manufacturers from bundling media players (car stereos) with their products.

The issue in the Microsoft case is not that they bundle (remember, they bundled their major applications into an Office suite, and nobody is complaining about that). The issue is that they are bundling a product with one where they have a monopoly. In other words, they are leveraging their monopoly to increase their market share in another market. That is what is illegal, and I think few economists would change that.

Is Microsoft a Monopoly?

Some people might take issue with the monopoly part, pointing out that they still have competitors in Apple and Linux. Well, Linux has only about a 5% market share despite being free, and Apple only remains a competitor because Microsoft still wishes it to remain one. Otherwise, Microsoft would have simply stopped offering MS Office for Apple machines. And one obvious motivation for keeping Apple1 is as defense against antitrust accusations.

But really, whether or not Microsoft is a monopoly depends on how you define monopoly. Some Libertarians seem to want to narrow the definition to government-sponsored monopolies (apparently for no good reason other than they don’t care about anything except government power — which is why I’m more of a small-l libertarian). Some would define it as 100% market share where there is no consumer choice.

Certainly, Microsoft fits neither description. But I would argue that the only reason to care whether a company is a monopoly is due to the monopoly’s negative effects on the economy, and thus that’s what to look for. After all, where there’s smoke, there’s fire (and the smoke is more likely to be what gets you anyway).

Monopolistic Pricing?

One typical drawback of Monopoly is that there’s so many darn little pieces that are easy to lose and you end up using Lego bricks in place of the hotels and… oh, wrong monopoly. Um, one drawback is that the monopoly typically charges higher than market value for its products and makes less of them. This lower output is exactly the opposite of the benefit that bundling and price discrimination bring.

Does Microsoft engage in monopolistic pricing? There’s a case for it, but it’s hard to say. Software, unlike most products, has a very low marginal cost. That is to say, creating a million copies of software doesn’t cost very much more than creating a hundred copies or even just one. Note that this isn’t true for, say, an automobile. And note that subsequent version of Windows aren’t really built from scratch, but are actually just new-and-improved (well, new at least) versions of older products. So it’s not clear whether Microsoft prices Windows above market value.

However, they’ve also used monopoly power to defend its monopoly market share, such as charging OEMs (Original Equipment Manufacturers) for a copy of Windows for every machine they sell even if the machine didn’t have Windows installed on it. I recall at my last company, one employee even tried to order a machine from Dell with Windows 95, and they refused to ship it without Windows 98 — even when she asked for it without any operating system at all so she could install 95 herself. Definitely something fishy going on there (and I don’t mean fishy as in the cute little fellas that swim around in aquariums).

Barrier to Entry

In my mind, the biggest sign of a monopoly is the barrier to entry for the market. This is pretty obvious in cases like cable television, where the government keeps competitors from entering, and it would cost a ton to dig and lay cable anyway. It’s less obvious for Microsoft, but real nonetheless. Although developing a competing OS is not expensive (witness Linux), the problem is getting people to use it. Because people don’t buy computers for the OS. They buy computers for the pornography they can download. That, and the applications they can run on it, kind of the same reason Sony’s PS2 dominates the game console market. And nowadays, a computer isn’t nearly as valuable to the consumer and to businesses unless it runs Microsoft Office (and Microsoft knows this, which is why they keep changing the document file formats so much). It’s ultimately what did in OS/2 (IBM, for some reason, didn’t even try to get OS/2 to run Windows 95 applications).

Lack of competition hurting quality?

Has Microsoft’s product quality (and thus, consumer utility) suffered due to lack of competition? I think it has. I recall MS Word used to be pretty good when they finally made it good enough to kill off WordPerfect and WordPro. I used to use WordPro’s predecessor, AmiPro, and when I switched to MS Word, I actually found it to be quite an improvement. Now, Word absolutely sucks eggs. I find it much harder to use (stylesheets used to be so easy to use, and now I find them bewildering), and it constantly tries to change what I’m typing in ways that are not welcome (what I type is always prefect, and does’nt ever need chagnig). Furthermore, it is extremely difficult to figure out what to change in the configuration to keep this from happening.

So I think that it’s pretty clear Microsoft acts like it has a monopoly and has a monopolistic effect on the market, which is good enough for me.

No good reason to integrate IE

Microsoft actually claimed that it wasn’t bundling Internet Explorer (IE), but was integrating IE into Windows to make Windows a better product. Anybody who used both Windows 95 and 98 probably already knows that was obviously false. But I can elaborate a bit from a technical standpoint that it is very poor programming technique to integrate applications into the OS. Software programs are very bug-prone, and thus need to be protected and isolated from each other, especially the OS.

Hiding information is good

Note that Object-Oriented Programming (OOP — no, seriously!) is a paradigm shift towards hiding as much information as possible between objects. This may seem counter-intuitive, considering that one reason 9/11 occurred was that our intelligence agencies didn’t share enough information with each other (and I myself urge people to absorb information from a wide variety of sources). However, programs are not people. People know how to process a lot of different information. Programs can only process the specific information they expect to get. Anything else, and they react very badly (think HAL from 2001).

In traditional C language programming, functions take inputs and produce outputs, and functions can call other functions to help produce complicated output. Passing inputs to a function is expensive, so programmers often use shortcuts by writing to a common memory area. Accessing the wrong memory (pointer errors) is probably the number one source of bugs in C programs. It’s especially hard to debug problems where one function’s memory area is overwritten by another, totally unrelated function. This is compounded by the fact that most projects have multiple programmers working on them.

Having multiple programmers also introduces the problem of interfaces. Engineers tend to be notoriously bad communicators (I think I’m an exception), so when a function written by one programmer has to call a function called by another programmer, errors are often made on what kind of inputs should and can be passed. Especially if the function was written by a programmer who no longer works at the company and wasn’t very good at documenting it (you’d be surprised how often that happens).

On the other hand, OOP forces programmers to organize functionality in such a way to minimize the amount of information passed between functions, helping to prevent the above issues.

Libraries

Sometimes, it is useful to have functions that many other functions can call, sometimes from different programs. These are typically put into libraries for easy access. Some libraries are statically linked, and are compiled into a single program file along with the calling function. Some libraries are dynamically linked (DLLs), where the program file isn’t functional by itself and needs to access a separate library file when it calls the library function. This can save disk space, but the drawback is a performance hit (not to mention they make installation and uninstallation of applications a nightmare).

The bonuses of using a library is that you reuse code, and thus spend less time coding, and when you fix bugs in the library, it’s fixed in all the places that it’s used. However, there are great risks when using libraries, due to the fact that it has the opposite effect of information hiding. First of all, when you write a library function, you are writing a function that a large number of other functions will call. If you make a change to the function (bug fix or adding a feature), this will affect a large number of other programs written by many other people. It’s very tough to make sure to not break any of them, so it’s key to have libraries as stable as possible, containing functions that ideally never have to be updated.

Good OS design

OS design calls for a similar type of practice. I’m, by no means, an expert. My first job did involve working on the kernel (the core of an OS) of a high-security system for three years. That was almost a decade ago, and I’ve been in the embedded systems world ever since, which has similar requirements but is rather different. I also don’t really know the internal mechanisms of Windows, so this is to the best of my knowledge.

The OS is the most critical piece of code that runs on your machine. Applications cannot run without it. If the OS crashes, the whole machine crashes. It also has the potential to do a lot of damage to your machine and your data. Typically, processors support multiple levels of security. The highest level is generally reserved to the OS kernel. Think of it as a VIP pass, where you are allowed to go anywhere you want (and also do anything you want — I guess it’s less like a VIP pass and more like being a rock star). You need to put a lot of trust into any code running at this level, and typically you want it to be the bare minimum as possible to get by to reduce the risk.

Good OS design often has multiple levels of security within the OS, placing the kernel at the most trusted level, other OS functions (like device drivers) at a lower level, and the GUI below that. Applications (like Word and IE) should be given the lowest level. This is because users will be installing and uninstalling applications from a variety of sources, so the code they run is much less secure, and the less damage they are allowed to do (due to bugs or to intentionally malicious code), the better.

Bad OS design

Well, when you have an application and an OS share a DLL, this poses a huge security risk. There’s no problem when the application calls the library function. The problem is when the OS, running at a high security level, calls the library function. First of all, there’s a huge security issue. The DLL generally cannot be protected from modification because upgrading the application will typically require updating the DLL. And since an application can update the DLL, a malicious one can replace a valid DLL with one that has a virus, and the next time the OS calls it, your entire system is instantly compromised.

And changing a library function — especially one called by the OS — is a tremendous risk for reasons I’ve already outlined. This risk is compounded by the fact that OS programming and application programming are very different, so it is tough to keep both worlds in mind when writing a function called by both. It’s really bad to have such a library function do something like HTML rendering, which tends to have a lot of bugs and needs to change whenever the HTML standard changes. Furthermore, HTML rendering is not something the OS ever needs to do. Ever. If you want to be able to share HTML rendering code between applications, that makes sense. But it has no business being in the OS at all.

Furthermore, the main benefit of using libraries is time-to-market. Reusing code means writing less code. Well, note that Microsoft already had working versions of Windows and IE that were separate. They had to spend time to combine them. So I think it’s pretty obvious that the only reason they bundled the two was to leverage the monopoly to win market share. And they did the same thing with Windows Media Player.

Bundling Security?

To touch on one last point, Craig Newmark, guest blogging at — once again — Marginal Revolution, cites the Los Angeles Times which has a strange take on how Microsoft, slammed for bundling IE, is also criticized for not bundling security features. This really isn’t correct. Bundling isn’t really applicable to an OS’s security any more than it is to a car’s fuel efficiency. It’s a quality of the OS itself and is affected primarily by the design architecture. Since Windows was not really designed with security in mind, it’s not surprising that security holes are found all the time, and that Microsoft is constantly sending out update patches to try and address them — amounting to little more than putting band-aids on a gusher. And of course, the main reason Microsoft can get away with such poor security is because they have monopoly power.

So to recap, bundling isn’t bad unless a monopoly does it to leverage their monopoly into another market. And whatever you say about their market share, Microsoft certainly acts like a monopoly, exercises monopoly power, and tries awfully hard to disguise its leveraging of its monopoly (quacks like a duck, so they say).

Now, what to do about it? That’s the tricky part.

¹ Steven Den Beste has another interesting theory explaining why Microsoft allows Apple to survive. A bunch of Apple people address his points here, and he seems to have gotten a flood of e-mails over it. I’m not sure why he just doesn’t have a comments section or allowed trackback pings. Then he’d probably get much less e-mail (and much less repetitive e-mail) and his readers would be exposed to alternate viewpoints which is the best strength of the blog format. Return