Twitter Not Rocket Science, but Still a Work in Progress

While it may not be rocket science, the Twitter team has been making a concerted effort to effect better communication with their community at large. Recently they were set-upon by a barrage of technical and related questions and the resulting answers are actually somewhat interesting. "Before we share our answers, it's important to note one very big piece of information: We are currently taking a new approach to the way Twitter functions technically with the help of a recently enhanced staff of amazing systems engineers formerly of Google, IBM, and other high-profile technology companies added to our core team. Our answers below refer to how Twitter has worked historically--we know it is not correct and we're changing that."

twitter hate...

Man, who *IS* this guy that his trolling has gotten its own front page article?

Re:twitter hate...

Dude, I'm not seeing the hate here. May be an eye of the beholder kind of thing.

I do have two concerns about the service, apart from the supposed outages.

One is that they don't seem to have any plan that can make money on their service. I suppose they are trying to build up a service that they can sell to Microsoft, Yahoo or Google, but how much of the user base is going to tolerate ads if any of them bought it as a platform to serve ads?

Another is that they are very quick to cancel passwords due to inactivity, requiring a request to get it reset. I don't know if it's one week or one month, but it's as if they don't want you at all if you don't log in at least once a week. However often they do it, I've not seen any other service do it so quickly.

Re:

I was attempting to make a joke based on the fact that everyone seems to hate the user named "twitter" who allegedly has a vast army of fake accounts he uses to reply to himself and create little Socratic dialogs to solicit karma.

of course, now its not fun

Re:twitter hate...

I have been confused about this also.
I DO hang out at places other than /., but until all of the '/. twitter' troll posts, I had never even heard of the twitter weblog. I assumed they were connected somehow and totally dismissed the twitter weblog.

Now that I have seen the twitter weblog, I'm still tempted mentally to associate the two, and want to spam it with goatse.cx links to somehow balance the shite. (just kidding-sort of)

I could not get an answer from the twitter weblog about how many sock puppet accounts you could register though, so I guess I will pass on the whole thing, and attempt to just filter 'anything twitter' from my web experience, as any more in my mind twitter==mindless rant.

And before some twitter (weblog) fanboy tries to bust my chops, yes I know I could be 'missing out on something' with that attitude, well that also goes for a million and one other websites that I currently don't know about. Save it!

Re:

I thought that the Twitter product was a free roving troll for all weblogs and somebody had figured out a way to profit from it.

So I went to the site and found I was correct. Its a AI-based troll that talks up products. Sadly there is a glitch where it als

That's "effect", not "affect"

This is one of those cases where "effect" is a verb.

Obligatory xkcd

Grammar [xkcd.com] can be fun!

i wonder what they mean by..

I wonder what they mean by "elegant filesystem-based approach"? Maybe their going to treat tweets like an email and store it all in the filesystem rather than a database? There's certainly some proven extremely high volume email servers so you know that method scales.

I wonder what the disadvantages of setting up a front end to an email system and covert incoming tweets to actual an actual email is. On the retrieval side you just read the mailbox and convert back to the tweet format then send them on to the destination.

Re:i wonder what they mean by..

I was founder of a top 100 internet site during the .COM era. We grew to serve millions of hits a day, millions of users, yadda, yadda, yadda.

We initially used a simple file based approach for user data (on vanilla Linux commodity boxes). It worked well.

As we grew, there was some pressure to move to a database approach, so we switched to Sybase (free on Linux). It worked well, and scaled us through a lot of growth.

However, eventually, when the database bogged down and no amount of tuning would help, rather than clustering, we looked at the nature of our data (a user's data was self-contained, generally not related to any other user's data), so having a massive relational database of hundreds of millions of records wasn't really necessary. So we went back to the file-based approach (with a good central "locking daemon" to ensure atomicity of writes), and gained a lot of performance (and simplicity). Even with thousands of bits of information or transactions for a user, a flat file is pretty darn manageable.

Generally people jump at databases as a default way to store data. If a single user's data is fairly manageable, and you have millions of users, there are times when plain old files suffice. (Doing some smart things like ensuring that directories don't grow arbitrarily and such also help, but that stuff is generally a lot easier than db design and maintenance.)

It sounds like Twitter didn't have well-thought out foundations, and they're reworking some of that. Good for them. (I've actually found some good consulting work in helping companies like them deal with scalability issues, from my experience with such things...)

Twitter Google App Engine

You know, I wonder how hard it would be to do a Twitter clone on Google's App Engine. It seems like it would be the perfect fit: relatively simple application that needs to be massively scalable.

Re:

http://meow.appspot.com

Re:Twitter Google App Engine

Someone already did this.
http://eric.themoritzfamily.com/2008/05/20/appengine-vs-twitter/ [themoritzfamily.com]

I haven't tried it tho.

Re:

http://www.jaiku.com/blog/2008/04/08/wroom-were-moving-to-google-app-engine/

I find it odd that this article is tagged effect.

It seems to be meant to suggest that the article's use of "affect" is incorrect. Surely this is mistaken. If suggesting that twitter has anything to do with better communication isn't an affectation, I don't know what is.

Plurk seems pretty stable so far

Plurk [is.gd] has been gaining popularity in the past 24 hours, and it's handling scalability rather well so far (after having been mentioned by Leo Laporte, Robert Scoble, TechCrunch, and others). I'm very curious to see how well it would hold up if it had the same number of users as Twitter, though.

Re:

That is interesting. Sounds like were still running on in house development level servers when the load hit -- ouch. If I do end up using such a site, I d rather say I'm Plurking than tweeting. It sounds much cooler, like something to do after having too m

Nice try...

but who would quit Google to work for Twitter???

Re:

Will "a rather pointless waste of time" fit on a postcard? I guess I'm not 'hip' enough to care about Twitter, it all seems a bit pointless for anyone who's not some interweb celebrity.

Re:And Twitter is...

...a geek-celeb circlejerk?

Alright, poop-time

I'm a twitter-shitter! [penny-arcade.com]

Re:Big Brother(s)

Hiring folks who used to work at IBM or Google is not the same thing as "large companies control[ling] how Twitter works." Some day, you'll have a job and you'll understand that. [Sorry to be an asshole about this, but your comment just shouts "teenage kid who's never had a serious job."] People with experience with large-scale applications may already know solutions to some of the problems Twitter is seeing. Those solutions aren't always in the text books; and if they were trivial and obvious, then such applications would be much more common.

Re:Big Brother(s)

To argue against myself on your behalf though, having someone from a larger corporation, can be benificial aswell, because they may have been fired, or quit because the larger corporation wasn't listening to them, or was doing something in a way that went against their ideology, thereby possibly preventing said smaller company from becomming similar to the larger one.

Like the AC said, I think you're wildly exaggerating how ideological workplaces are, particularly from the point of view of a server monkey.

Re:

Oh, ideology affects cage monkeys. The use of open source versus closed source, burchasing enough licenses for the software you use, and making '99.999%' uptime actually mean that instead of simply hiding downtime, and forcing people to spend more time doc

It's the algorithm, stupid

Ruby is not Twitter's problem. The algorithm Twitter uses is the problem.

When I started irately writing this post, I wrote it in a tone that would have gotten me modded into oblivion. But then I realized that ignorance, not idiocy, drives the particular myth I'm debunking. let me educate, not flame, those of you who haven't formally studied computer science.

It's become fashionable to blame Ruby for Twitter's problems, but that's wrong. The particular choice of language doesn't matter a bit when you talk about scalability, no matter what the language or the problem.

First, sending a twitter message is an algorithm. An algorithm is just a recipe for doing something to some data. Although most computer science literature deals with more abstract and general algorithms, like those for sorting and searching, the same principles applies to even the most mundane processes, like what rm foo does to a file system, or how a database engine runs an INSERT.

One way we can talk about algorithms is to use something called Big-O Notion [wikipedia.org], which describes the relationship between how much stuff an algorithm processes and how long it takes to run.*

It's easier to see things with examples. Say we have an algorithm and we give it three sets of data, D1 and D2, and D3, each twice as large as the last, so that D2 is twice as large as D1, and D3 is four times as large as D1.

If we call the algorithm O(1), it will take the same amount of time to process D1, D2, and D3. If we instead say it's O(N), D2 will take twice as long to run as D1, and D3 will take four times as long.

If N represents the number of users for a web application, and we want to double N, twice as many users, we'd need twice as many web servers if the bottleneck algorithms are O(N). If the database is the bottleneck, we'd need a twice-beefier database server, or some partitioning.

Things start to get interesting with O(N^2). In that case, D2 takes four times longer to run than D1, and D3 takes four times longer than D2, which sixteen times longer than D1.

That means that if we want to support twice as many users, we need four times as many web servers, or more likely, a four-times beefier database server.

It can get a lot worse than O(N^2) too, especially if you're not paying attention to complexity. For example, many graph (think social networking) algorithms can easily become O(2^N), which is a lot worse than N to a constant power.

When you try to scale a poorly-designed algorithm (pretty much anything worse than O(N)), you start running out of cores, rack space, electricity, and atoms in the universe.

One useful bit about big-O notation is that it lets us ignore piddly details that don't matter. Say we had an O(2N) version of the O(N) algorithm. Sure, the O(2) algorithm might take twice as long to run, but it can still handle double the data with double the capacity or double the time. Even if it's O(10N), you don't start boiling the oceans to cool your data center when you want to increase your visit capacity a thousandfold.

This observation is why the choice of language doesn't matter. If a language implementation is slow, all it does is add a constant factor to any algorithms written in that language. A Python application might be ten times slower than one written in C, but its big-O complexity will be the same.

At the worst, that means you'll need ten times as many servers as with the C web application. The increase in development efficiency writing in Python (or Ruby on Rails, or Lisp, or anything else) might make the trade-off worth it. You can deal with a constant factor slowdown.

If on the other hand, you code a wicked fast implementation of an O(N^3) algorithm in C, no amount of hardware will save you. You'll hit a number of users beyond which your servers slow to a crawl and you lose blagosphereic karma. Even if you double your capacity, or buy a four-times-beefier database server, that

Re:It's the algorithm, stupid

Thank you for your polite reply, but I feel like I haven't adequately communicated my point.

The language you choose may affect your ability to scale when you take its concurrency model (or lack thereof in some cases) in to account. For instance, I can have a O(1) algorithm, using a hashmap, but that doesn't mean that I'll be able to have the runtime performance of constant time.

If your whole web application is bottlenecked by one hashmap, you're going to run into scalability problems as soon as you need more than one machine anyway. On the other hand, If the performance of the web application as a whole does not depend on the hashmap, then your argument is irrelevant to the scalability of the application as a whole.

I concede that a more efficient runtime environment might make better use of the same hardware, supporting, say, 70 clients instead of 50 per machine. But that's not the kind of scalability I'm talking about. Even a platform that achieved only one client per machine that scaled linearly would be better than one that handled 70 clients per machine, except that you were limited to one machine.

And yes, on one machine, a bad choice of data structure can affect scalability. But the blame for that rests on the data structure itself, not the language in which it is implemented. As an associative array, a Python hash table (dict) will scale far better than a C linked list. Why? Because one's a hash table and one is a linked list!

Which data structures are available in which language might factor into the choice of language, but it's only a convenience: you can always create your own data structure implementations.

Granted, there are ways around this, but you can't just throw hardware at the problem and pretend it doesn't exist.

Creating a scalable application means being able to throw hardware at the problem.

Let's assume you've gotten your application to scale beyond one machine anyway. That's a prerequisite for this section.

Now, if the machines don't communicate and users don't care, you automatically win O(N) scalability.

If your machines must communicate, they do so over some kind of network. The way this communication is achieved determines the scalability of the application. While some environments might have more intuitive network facilities than others (think Erlang), ultimately one can use any approach to networking with any language.

Again, we're reduced to choice of data structures and algorithms, not language, as the marker of scalability.

The choice of language does not dictate the data structure the designer of the application uses, and so the language is not a serious barrier to scalability. I concede it may be more difficult to implement efficient protocols in some languages than in others, but we're dealing with turing-complete languages here, aren't we?

I should note that languages typically thought of as "slower" are often more expressive. It often takes less effort to write efficient algorithms in expressive languages.

(Returning to our previous example, since writing a hash table is more complex than writing a naive linked list in C, a C programmer is more likely to use a linked list at the expense of scalability. In Python, using a hash table is as simple as writing {}, so an equally-skilled programmer is more likely to use the more efficient data structure, resulting in better performance in a "slower" language.)

The bottom line is that if communication between nodes is required, complexity must be > O(N). And if complexity is greater than O(N), then as N increase without bound, the communication overhead approaches infinity anyway. The key is to make that growth as slow as possible.

The tools and techniques used to slow that growth --- thinking about the problem, designing efficient algorithms --- are features of the human mind, and not any particular language.

Saying that one la