Walmart Computing – Understanding Utility Computing and Economies of Scale

Walmart computing is the new term I’m inventing to describe what happens when the Utility Computing or one aspect of the Cloud computing movement makes it bigtime. The idea is simple enough. As more companies access virtual resources instead of real, physical servers then that will result in a reordering of the infrastructure. That reordering will also imply massive cost changes, like I’ve written about before over at LayerBoom.

Once the big companies that offer these virtual services realize how unimportant seeing the actual server is, they’ll just start buying containers of servers instead, similar to what Microsoft is doing with their new data center in Chicago, and that means that on a per-server basis, you’re going to get a way better price. When you’re buying 1000′s of servers, you just let them fail in place, and replace the whole container after a certain threshold (does anyone have any best-practices for this?)

Big companies have buying power, and when you buy things in such large quantities you can get big discounts. Not only that, but you can also justify customized chipsets when you order a million instead of 10. That’s why I call it Walmart Computing. When you’rea huge company with tons of buying power, you get to set your own price. (Perhaps there are even acquisition possibilities?)

There are a lot of interesting papers and blogs written about this subject. James Hamilton over at Microsoft has an amazing paper entitled ‘Emabarassingly Distributed Cloud Services“, and Rob Snevely of Sun published “Enterprise Data Center Design and Methodology” which I have yet to read but have heard great things. What’s most interesting about these papers is that they prefer the modular distributed approach to designing data centers and services, rather than the large bulky approach we use right now. Personally, I’ve been totally converted to that school of thought. James Hamiltons paper has some great numbers but I can summarize it here. For certain services, it’ll cost you about half as much to build the infrastructure in a distributed fashion, rather than a centralized one. The nice thing is, most applications we use online can be “embarassingly distributed”, but that’s perhaps a blog post for another day.

blog comments powered by Disqus

google.load("language", "1"); var curstate = 0; var hasloaded = 0; function bnc_show_translated() { if (hasloaded == 0) { bnc_lang_callback(); hasloaded = 1; } for (i = 0; i < 0; i++) { var elem = $("bnc_original_" + i); if (elem) { if (curstate) { elem.show(); } else { elem.hide(); } } } for (i = 0; i < 0; i++) { var elem = $("bnc_trans_" + i); if (elem) { if (curstate) { elem.hide(); } else { elem.show(); } } } if (curstate) { $("bnc_trans_state1").show(); $("bnc_trans_state2").hide(); curstate = 0; } else { $("bnc_trans_state1").hide(); $("bnc_trans_state2").show(); curstate = 1; } } function bnc_detect_div(div_id) { var text = document.getElementById(div_id); if (text) { text = text.innerHTML; if (text.length > 0) { google.language.detect(text, function(result) { if (!result.error) { if (result.language != "en") { if (result.confidence > 0.25) { $("bnc_translating").show(); bnc_xlate_div(result.language, div_id, "en"); } } } } ); } } } function bnc_xlate_div(src_lang,div_id,o_lang) { var text = document.getElementById(div_id); if (text) { text = text.innerHTML; google.language.translate(text, src_lang, o_lang, function(result) { var translated = document.getElementById(div_id); if (result.translation) { translated.innerHTML = result.translation; } }); } } function bnc_lang_callback() { } function bnc_startup() { bnc_xlate_div("en", "bnc_translate_info", "en"); bnc_xlate_div("en", "bnc_translate_info2", "en"); } google.setOnLoadCallback(bnc_startup);