April 27, 2006
The Long Tail of Advertising Getting Longer
No kidding - I think its really going to be like that old Saturday Nite Live skit, the Change Bank.
Change Bank: "We make change for you. You got a $1, we can give you 20 nickels. Or we can give you 5 dimes, a quarter, and 25 pennies - its all up to you."
Customer/Narrator: "How do you make money?"
Change Bank: [deadpan] "Volume".
See my earlier post, also from yesterday.
April 26, 2006
The Long Tail (the book) and
Remnant Inventory Management
Optimization has always been of interest to me, and not just the optimization of code. Now, to be clear, I tend to think of myself more as an algorithms type person than an optimization specialist (for example, I abhor Assembly programming for anything and everything), because living in the margins just doesn't seem that fun. In the business world, for example, this usually takes the form of arbitrage of some kind - there's gold in them thar' hills, to be sure, but I don't know - it just doesn't generally draw me in, intellectually.
All that said, I do believe that having a mental framework for optimization - understanding the "why's" of performance (code or business) - is important in designing the right strategy for execution. And that definitely does get me going. (And, yes, when absolutely required, I will advocate Assembly :))
In that vein, one interesting "emerging" category of business optimization is remnant inventory management. Its not that its new - supply chain operationalists understand well the opportunities, and waste management (er... productivity/production/inventory/etc. optimization, not Sopranos-style) is a lucrative "hidden" field. As I said, mostly this is in the margins, though its a core part of operational excellence for any major company: building to order, material expenditures, lean inventory management, etc., because those margins can be large.
And, of course, people in the advertising business (online and otherwise, especially Print Publishing) know all about remnant inventory - those are those ads in random spots that no one really wants. But somebody's got to buy the ad on the bottom half of page 34, after all - the space it already allocated.
I mention all of this because I came across a new book on Amazon, by Chris Anderson (of The Long Tail fame), called (appropriately): "The Long Tail: Why the Future of Business is selling Less of More".
I haven't read the book yet (its not out yet :)), but its sure to be a good read, and I agree with at least the title - how's that for a ringing endorsement? :P
My belief is that this New Media Economy will be primarily won or lost by applications, not content . However, I'll posit that in any case, deriving value from resultant traffic/eyeballs/attention will be about tail optimization - and that, in turn, will require scale to be effective.
April 24, 2006
Sree's got a brand new bag
More than a year ago now, AOL reorganzied itself into 4 Business Units (BUs): Access, Audience, Digital Services, and AOLE (Europe - the other three are US focused). The big reason for that move was to enable focus and prioritization on value drivers that were/are fundamentally different (getting online, advertising , digital commerce, etc.). As a part of that, we've also been working to move the front-end application development teams into the BUs to be integrated parts of the respective businessses.
We (finally) finished that some weeks ago, and I'm proud to say I now run what we've christened the "Open Services" group at AOL, reporting to the CTO. While the application front-ends are in the BUs - focused on the next releases of those applications and the BU immediate priorities, my team is respnsible for the enabling technologies and infrastructure development that powers the entire business, today and (more importantly) into the future.
Included in my group are: Desktop Client infrastructure (OCP), Host infrastructure (SOA), Instant Messaging and Realtime communications, Publishing systems, Search development, Mail Host infrastructure, and the new Billing and Business Systems.
That "Open" part of the group is very important to our future strategy, and you'll be hearing more about that shortly.
April 23, 2006
P2P: Peer to Peer and Network costs
The short (short) version: although P2P technologies relieve scalability and cost problems for the originating server(s) - which is good for scaling the Internet, they don't help at all with the Network infrastructure congestion and cost issues, which is not so good.
There are some extensions and exceptions to that (for example, P2P in corporate LAN sort of helps shift some of the costs), but by and large, the reason that some ISPs, University sys admins , et al, are crying foul: it costs them time and money to deliver value for someone else.
And these are only the leading indicators...
April 20, 2006
SPAS: Search Spam -
an RSS/SEO Mashup Love Story
http://ptbhkzj.jhloan.com/issue/subtlety.html
http://memory.urnf.com/memoryram/
If you haven't yet, I predict you will.
Welcome to the new world of unwanted information: Content spam that targets Search Engines. By combining relevant auto-categorized (real) RSS feed data with good cross-linking to (real) sites, clean(-ish) URL structures, and semi-static perma-linking concepts - well, they show up as "relevant" in search engines for the appropriate terms these pseudo-sites are targetting. Usually not on the first page of search results, but high enough that they get a little bit of click through (and revenue). Rinse and repeat a few million times - these are machine-generated pages after all - and, heck, the business case just writes itself. And I'm probably not helping by linking to them...
This isn't Search Engine Optimization (SEO) gone wrong, which is how most people think of Search Engine Spam (SES) - that is, benign or malicious conscious manipulation of search relevancy. This is what I call SPAS (pronounced "spaz" :)) - SPAm for Search - feed aggregated auto-editorial content that, for all intents and purposes, mirrors a modern content publishing system - except its editorial gibberish and Internet pollution.
Or is it?
How are these sites any different than Google News? Reselling someone else's content, by organizing it, is the entire premise of the Search Engine business model.
SPAM (unwanted mail).
SPIM (unwanted instant messaging).
SPAZ (unwanted search [results]).
Flickerlish Nosescums, indeed, Jack.
April 19, 2006
JavaScript Applications, pt 3: Optimization and Compilers
There was some small amount of confusion regarding my point about chained calls at the end of my last article on JavaScript. Although nearly every JavaScript optimization article suggests the same optimization (explicitly caching nested property access into a local variable) - and I agree with it, especially for DOM access - my main point was NOT about optimization at all (per se), but rather the idea that understanding that this is an optimization.
There are two distinct reasons that JavaScript can be slow(er), and its useful to separate them in attempting to achieve optimal performance, and, more importantly, in understanding how best to use JavaScript in large scale application designs:
1) JavaScript is (usually) an interpreted language
2) JavaScript is a dynamic language
There's been a fair amount of work around JavaScript compilers and compilation, most notably from Microsoft (JScript.NET and the CLR) and Adobe/Macromedia (Flex beta 2 and Flash 8.5 Player). And while compilation (and just-in-time compilation) can help with some class of things (not to mention Moore's Law helping out over time), the very dynamism that makes JavaScript useful as a rapid-application-development and prototyping language continues to make it necessary to internalize the trade-offs that causes.
Basically, because (among other things) dynamic essentially translates into "late binding" for property discovery, even compiled JavaScript won't address many of the Programming-in-the-Large problems - those are better handled by classes, prototypes, strict typing, co-routines/generators and the like (which I'll cover in a future JavaScript post) - some of which are really future JavaScript features. For now, if want to scale your JavaScript applications, properly leveraging instantiation and the binding model is really the key. Compilers won't really help, and the interpreter isn't (really) the issue.
By way of example, it's often said that the Microsoft .NET CLR isn't good for dynamic languages.
Its not so much that its not true (IMHO), as that its misleading. The Microsoft CLR (VMs, JIT-ing and compilation generally) just don't particularly help for dynamic languages.
Let's look at a simple benchmark (JScript.NET version shown):
function benchmarkmath() {
var x1 : double = 0;
var x2 : double = 0;
var x3 : double = 0;
for (x1=1; x1<=10000; x1++)
for(x2=1; x2<=10000; x2++)
x3 += Math.sqrt (x1*x2);
}
[I got this from a site that I can't find anymore, so apologies to the author - I'll link to it as soon as I dig it up...]
The benchmark does some very simple floating point math (multiplication and addition) in a tight loop (100,000,000 times) that also invokes a complex "native" math function, Math.sqrt. Though I wasn't able to replicate the timings listed on the site (which showed that C, C#, and JScript.NET were basically the same), here's what I saw on my 1.2Ghz Pentium 4:
C(Visual Studio): 5.6 secs (provided only as a baseline)
JScript.NET(MS CLR): 10.8 secs
Flash Player 8.5(Flex): 20.7 secs
JavaScript(SpiderMonkey): 193.75 secs
Cool!
The JavaScript compilers really did well - and so JavaScript is slow because its just an intepreter in the browser, right? This would be seem to be further validated, as when I performed the same benchmark with previous Flash Players (which had not only a "regular" interpreter, but a SLOOOOOOOW interpreter), we see that this test takes over 1000 seconds (I stopped it because I got bored).
However, I then leveraged the basic "optimization" I mentioned above and removed the chained call. I basically added a variable (var f:function = Math.sqrt), and invoked that instead of the Math.sqrt function directly. New times:
JScript.NET: 114.4 secs
Flash Player 8.5: 116.7 secs
JavaScript: 178.9 secs (note the small win for the chained call removal here)
Oops.
Apparently, the JavaScript compilers can inline (or at least reduce to a jump) the call of a function on an immutable object. Once it becomes a little dynamic.... not so much. You'd hope the virtual machines would do some caching of property look-ups or something, but this is indeed harder than it first sounds because of the (potential) volatility in dynamic programming contexts.
So if your design scales beyond the trivial, not much help is coming for this direction.
Still, the dynamic nature of the language does afford a fair amount of power - one just needs to understand (how to avoid some of) the costs. In particular with Object Oriented Programming (OOP) paradigms and JavaScript, its important to remember that nested functions are NOT classes, though they look like them, i.e. emulate some of their behaviours.
I meant to delve into that more this time, but it'll have to wait I guess.
I can't recall exactly where I was going with this series, but next time I'll (finally) cover some specific JavaScript optimization and performance tips and recommendations, for JavaScript in the browser as well as compiled, with some time tests/benefits. Again, this isn't about performance, exactly - just that understanding the "why's" of the performance is useful in understanding the strengths and weaknesses of the language itself.