Python Twitter Tools 1.6

I am proud to announce Python Twitter Tools 1.6, with awesome new features:

  • twitter-log: a new command-line tool to dump all of the tweets you ever tweeted to a text file for storage and archiving
  • stream support: with the new TwitterStream class you can write Python applications that make use of the Twitter Stream API for realtime updates. Try the twitter-stream-example program to dump all the tweets in the “sample” stream to your terminal. Neat!
  • Python 3 support: The twitter distribution in PyPI now supports Python 2.6+ and Python 3.2+ using the same codebase. You don’t have to use the “twitter3” package anymore. Python Twitter Tools is now future-proof.

As always this is available on the Python Twitter Tools homepage or in PyPI.

Is that all (folks?)

You might have noticed my last post/rant “Screw Twitter”. Yeah. Truth is, the Twitter API is still awesome and I had a lot of fun working with it. However, I disagree with Twitter’s decisions and recent policy changes over their use of the API and with the data that flows through Twitter. It seems to me that we cannot allow such a powerful communications channel to reside in the hands of one company. And that isn’t even Twitter as a corporation’s fault. It’s just… corporations like money, and information companies will naturally control information flow to make money. That’s normal.

So: Python Twitter Tools may have bugfix releases (and I may be tempted to add features here and there) but I think I will spend my time on other projects.

(No, not Minecraft.)

Screw Twitter

Okay right, let’s go.

So I make this Python Twitter Tools library which, for the layman, is a piece of software that lets other people write programs that interface with Twitter more easily. I’m quite proud of it.

Twitter is nice because they provide an API: a way for programs to access data about twitter messages and users. They don’t have to do this, but they do, and the various Twitter-enabled applications are one key that made Twitter so successful.

One killer thing about Twitter is that you can use it on your iPhone or Android phone. Back in the day the best way to do that was with Twitter client programs. Other companies built programs just for interfacing with Twitter, and because they were competing with each other, the clients got better and better. All of these clients are dependent on the Twitter API to send and receive messages.

Recently Twitter bought the best third-party Twitter client company and released a new version as the “official” Twitter desktop and iPhone client. That’s fine. It will help them get more users.

What’s less cool is that they have started saying worrying things about the use of their API. Amongst other things they don’t want other companies making Twitter clients anymore.

Their reasoning is simple: User Experience. They want their official clients to be the only gateway to the Twitter ecosystem. Other programs are free to interact with the API but their functions must be different than merely displaying and posting messages.

Twitter controls which applications are allowed to connect with their API, and they can shut off a “master switch” and deny an application access outright.

This stinks.

I’ve just finished reading Tim Wu’s book “The Master Switch” which deals with the history and future of communcations mediums. In virtually all cases, systems start out as open, and then become closed monopolies over time. Closed monopolies then stifle innovation and limit service to increase profit.

Terrifying things have been done in the name of User Experience.

It used to be that there were no telephone jacks. All telephones in the United States were built and installed by AT&T. You simply could not connect any other devices to the telephone line.

The American government, of course, suspected this was not very fair and confronted AT&T, but AT&T’s reasoning was simple: they could not guarantee a decent User Experience if the telephone device was not built by AT&T. Users would get angry at their shoddily-made telephones and blame the network! Callers to those with badly constructed phones would also think badly of the AT&T system.

Did this stop innovation? Yes. For example, Bell Labs had built a telephone answering machine as early as the 1950’s, but AT&T decided they were not interested in selling it. Nobody else could build one because it would be illegal to connect the device. Similarly, modems: those devices that started the home-Internet revolution could never be used in a monopolistic AT&T system.

It was only when AT&T was forcibly dismembered in anti-trust hearings that the telecommunications market exploded with innovation. Innovation that lead in many ways to the Internet.

So then we have Twitter.

Twitter was always closed. There was always one company at the core of the service, and so we can’t claim it was ever truly open. However, Twitter users and Twitter client developers trusted that the Twitter network would stay benevolent. Somehow it would allow “common carriage”: to allow any type of short message to travel its networks and any type of software to send and consume messages. This is no longer the case.

Twitter is closing inward to make money.

They are legally allowed to do this, but that doesn’t make it ethical.

What does this mean? Well, personally it means I don’t have much taste to further develop my Twitter library and applications because I don’t want to support an enterprise closing in on itself. (My code is open source so I trust others will take it and extend it for their own uses).

The last Twitter application I built was an exporter. With a single command you can dump all of your twitter messages to a text file. This can be technically done though there are some statements in the API “Rules of the Road” which suggest this might not be allowed. Which begs the question, do your own your own tweets? I’d say copy them out now while you still can.

Hopefully, someday, there will be an open and distributed short messaging system that one can then import their messages into. But that’s a much larger project I’m still thinking about…