Mitter public annoucement: Mitter is going git

Just to let everybody know: Mitter will not use Google Code SVN repositories anymore. The source is still available for those that know the URLs but the information is not available to the public anymore. Other things like Wiki, issues and downloads will still be available in the Google Code space.

Mitter source code is not being hosted with Gitorious and it’s available for everyone to clone it. Also, Gitorious offers options for automatic cloning so all you need is a Gitorius account.

Small PQA (Possibile Questions and Answers):

  • Why Git?
    For one thing, I’m feeling comfortable with Git workflow and tools. Second, I prefer the way Git does “in-place” branching, so you don’t have a lot of directories laying around your disk.
  • Why Gitorius and not GitHub?
    I know how GitHub is everybody and their mum’s favourite git repository and interface. But, as an open source supporter, I chose Gitorious exactly ’cause they provide the source code of their project for everyone. I’m not saying that GitHub is wrong charging people for their project, it’s just that I prefer to support open source.
  • What about the other branches that were laying around in the SVN repository?
    They are still there, but I didn’t import them into Gitorious. Most of them were not being used anymore but, if something is needed, the source is still there.

If you have any other questions, feel free to ask.

The current state of Mitter

I just tweeted about this, but better put here so everybody knows:

Mitter trunk (from SVN) is broken. Broken, broken, broken.

Why? It all started when I realized that all interfaces where saving the last seen tweet and last seen reply. Also, to cut the seen replies and tweets, the interfaces were actually removing the seen ones from the result set. In other words, we were requesting the full page of tweets/replies and then ignoring the ones whose ID was below the last one the interface displayed. Twitter supports a since_id parameter, which was created exactly for that. Also, we were requesting just the first page, so if you didn’t open Mitter for a while, you’d not see some tweets.

Also, for a long time, there is a hack to make console interfaces work properly. Due the nature of the graphical interfaces, we need to create a thread (kinda like another process, if you don’t know what a thread is) so when requesting data the interface won’t freeze. That’s not an issue for console interfaces and, to make them work properly, I had to add a hack, which make the code even uglier. The removal the thread broke the GTK interface completely… for now; I have plans on how to fix the GTK interface and they will be added as soon as I fix the network bit.

During this time, there was another thing bothering me: The amount of hard-coded values. The GTK interface, for example, only keeps 60 tweets in the list. Problem is, if you want to keep a bigger list, you’d need to change the code directly. That’s not a good solution to me, so the idea was to move everything to the config file, which pointed to the second big design issue: The options were floating all around the code. Keeping option values coming from the command line and from the config file was a mess. For that, I decided to create my own OptionParser (the command line option parser) and ConfigParser (the config file parser) combinator. Yesterday I finally finished ConfigOpt and I intend to move all Mitter options to use it (which will make our code cleaner and hard-coded values free — or so I hope.)

And, since I’m working in all that, I decided to start paving the road to multiple network support. A tiny bit of it is already there, but there is also a long way to reach the final line.

There is still a long way to finally make Mitter stable again. But we’ll get there, I promise.

Is Mitter dead?

As some may have noticed already, there haven’t been many releases of Mitter lately. But it doesn’t mean Mitter development is dead. I’ve been working on some things lately:

  • Multiple network support:
    One thing I’m trying to make now is support for multiple networks, so you could update your status on Twitter,, Facebook, Jaiku and whatever from just one client. The weird thing is that, this time, I decided to actually write the design down and then start working on it, to avoid creating a mess of code but, in the end, every single step I did into code proved that I forgot something (yay for Python and fast prototyping!) I still see some rough edges everywhere, but I think after a week working on it, I got a huge step forward.

  • The damn network thread:
    Not something I’ve been actively working on, but I think about it from time to time. The main reason it bothers me is the problems with the PyGTK main loop on Windows and the ugly ugly hack for the console interfaces (tty and cmd.) At first I thought about converting the network interface into a file-like object, so it would be just a matter of “read()” the data, but that proved to be a problem with the idea of multiple networks. Right now, I want to try to split the HTTPThread into a single object and the interfaces would be able to mix it with the Network/Twitter objects. So, only interfaces that need threads will have a HTTPThread-like object to use; interfaces that don’t have that problem will use the Network/Twitter object directly.

  • Tk(inter) interface:
    Also with the problem with PyGTK on Windows, I decided to play a little bit with Tkinter. Now, everyone knows that it looks pretty bad on X11 interfaces, but on Macs and specially Windows, it tries to mimic the OS look (even more on Windows, where it translates Tk commands directly into Windows.) So far, it looks alright and I even have a working prototype (not plugged into the Mitter object yet, though.) Here are some screenshots:

    The first thing you’d probably notice is that it doesn’t look like the PyGTK interface. That’s because Tk supports only one line for items on listboxes, so I had to make a space for the whole tweet or you’d get just a glimpse of the text. I’m not looking into links and other stuff yet, but maybe in the future.

Mitter 0.4 “He left us! He left us!” released

Mitter is a simple application to keep your Twitter status up-to-date and to see your friends updates. It aims to be simple and with a small requirement list, while supporting multiple different interfaces.

New in this version:

  • Added a right click menu with all the options, plus separate options for links in the tweet and a new “Retweet” option.
  • Added support for multiple config files.
  • Updated desktop file.

And fixes:

  • Fixed a problem with the loading of some avatars.
  • Fixed a crash when loading some icons.
  • Fixed the char count in double-byte languages.
  • Fixed a problem which was preventing tweets to be deleted.

Download available in project page.

Mitter and the Future, part Troix: The Alternatives

(This is getting long, doesn’t it?)

One more point to analyze the future of Mitter: The Alternatives.

Right now, the space that Twitter fills is getting crowded. Not that Twitter was there first, but it surely is the widest, most recognized service in the area. And, most of all, I’ll list one the ones I have an account.

  • Twitter (me): Ok, you all know Twitter. 140 chars, used to have updates and notifications via IM (but is down for a very long time already), updates and notifications via SMS.
  • Jaiku (me): Was there before Twitter. Works almost the same way: Messages are limited to 140 chars, updates and notifications via IM and SMS. Also, it provides a proper “reply to” function, which allows you to do a reply to an specific message (Twitter always points to the last message from the user you are replying to.) The problem with Jaiku is that, about an year ago, it was bought by Google and they closed the service to everyone. Right now, to get an account, you need an invitation code by someone that already have an account there.
  • Pownce (me): Offers way larger messages (around 400 chars, if I recall correctly), proper replies, can share links, files and events. Doesn’t have IM or SMS notifications (or updates) but you can receive notifications via email.
  • Facebook (me): Although it is a social network thing, it have a “What are you doing?” field (originally, it was a “[Username] is …” field.) As far as I can see, the status can be longer than 140 chars (but I’m not sure how long.)
  • (me): The new Twitter clone, but completely open source. You can download the sources and run your own service. And, because it works with the Open Micro-Blogging Protocol, you can still reply to people using other servers.
  • Tumblr (me): Tumblr works a little bit like Pownce: You can update your status, post pictures, links, audio and video. One the nice things that Tumblr does is create a page that actually looks like a blog to you.
  • Plurk (me): Almost the same as Twitter (140 chars), but it can save some space with “actions” (you start you update with a pre-defined verb.) Again, like Twitter, they have IM notifications and updates, but it’s down for the moment. They have a timeline feature, which displays the “progress”

Now re-read the list and notice that every single alternative offers things better the Twitter. And, still, none of the them actually harm Twitter’s popularity. Heck, not even the FailWhale seems capable of harming that. But, still the point remains: There are alternatives to Twitter, which work better and/or offer more features.

Which brings us back to the point of “plugable” networks…

Mitter and the Future Part Deux: Community

Still in the line “What will happen to Mitter now that there are more options around” let me say that one of the things that are driving me back from Twitter development (or, better saying, developing Twitter applications.) is the community of developers.

When I started Mitter development, as usual I decided to lurk around the Twitter Development Talk, a list created by the Twitter developer themselves to talk about the directions of the API and the service. Long before Twitter became the synonym of “it doesn’t scale”, the discussion was always productive, with very small traffic. But it went really downhill after that.

You could find people saying that Twitter decided to close their garden only to read, a few messages later, that they were really abusing the system; a lot of “Twitter is not sending data properly, you broke my product!” complains, when they should be ready for anything and should be way faster if they solve thing on their side. It goes way down, to the point of people almost demanding when Twitter will fix their side. And always almost demanding Twitter to fix their problems.

I’m not trying to defend the brokeness of Twitter. It’s annoying and recently was enough to made me do a quick release ’cause Mitter was crashing hard (due some really broken JSON result) but… demand a fix from a free service? Complain about a service “destroying their business plan” when they were actually abusing the system? Sheesh. People, it is a free service and they have the right to simply close the API ’cause people don’t behave properly. They have no responsibility for your client or your business model.

And the worst part is that Twitter would usually bend over to make those guys happy. It saddens me to see a product with potential being directed away from its original vision to something to make everyone happy. Honestly, what’s the point of developing something for a product that may not be what they pronounced it would be?

Don’t get me wrong about those two posts. I loved Mitter and I still think it’s the best Twitter client around. I surely still want to make it become better and better but, each passing day, I feel more and more disconnected with Twitter.

Mitter, Maemo, and the Future

When I started Mitter, my plan was to create a client capable of updating my Twitter status using my N800. Since I could carry it everywhere because of its small size, it would be perfect. And I could do that using Python and PyGTK (PyHildon, but it’s almost the same thing.) My plan was quite simple: write a client small enough but capable of using multiple interfaces. That way, I could write the starting code without using Maemo and later just convert it. It may sound a little bit weird, but first I needed the network bits in place and then, later, I could just plug the interface. Even as today, I still have to fight the network layer (mostly because I didn’t made good plans about all that and a little bit because Twitter changed since I started the project [mostly the limits and user behavior].)

A few weeks ago, Mauku, the Maemo client to Jaiku (the micro-blogging platform now owned by Google), announced that they will have support for Twitter. Now users have an option to update their Twitter status in their N770, N800 and N810. Basically, Mauku did was I was trying to do for a long time.

And all that around a time when Twitter is under, let’s say, “attack”. Users are getting annoyed by the Fail Whale (the message shown when the services are down), although the situation improved considerably in the last month or so (but still, the little glitches, like followers disappearing without any good reason, still happen from time to time.) At the same time, competitors in the Micro-blogging arena are emerging. While Jaiku is another service in the same model of Twitter, it’s now closed for new registrations and you need an invitation to create an account there., an open source competitor, suddenly appeared and seems capable of “stealing” Twitter users.

So, what are the plans in the future of Mitter? At this point, honestly, I don’t know. What I would really like to do is completely split the network bits from the main application, so you could plug networks are easy as you can plug interfaces today. There is an experimental (although completely functional) status update for Facebook on a separate branch. The reason it’s there is because I didn’t find a way to split the network layers properly. If such split was something easy to do, you could post to facebook, Twitter and probably

The fact the have it’s source open is something that really compels me. And, by that, I mean that the next fail whale I see I’ll stop using Twitter and move to

And what about Maemo? Well, since the interface is still plugable, it’s just a matter of writing it. My current problem with the Maemo platform is the environment. Installing Scratchbox is a pain lately, due:

  1. I have a MacBook now and PyGTK development on it is pain. Most visualization tools are slow or behave badly (or, at least, weren’t so pleasurable to use.)
  2. PyGTK on Macs is slow and buggy (either the X11 version or the Quartz version.)
  3. Scratchbox insists in breaking every now and then.

I think the last point happens a lot ’cause Scratchbox virtualizes the Maemo environment (an ARM processor.) So, any small changes on the host operating system makes it behave badly. Also, the fact that Nokia decided to create their own widget set based on GTK instead of doing something like the Windows port does makes things harder. I’d love to write it in PyGTK and not having to deal with the conversion to PyHildon.

All that sounds good and all, but you must remember that I’m just one guy. Although Deepak helped me a lot with fixes to the PyGTK, it doesn’t increase the count that much. And he (and so I) have a lot of other projects going around. If we go for another interface and another network code, it would be really hard to maintain such beast.

I don’t want to stop working with Mitter. But, at the same time, things are less compelling in this space for now. Maybe if I really managed to split the network and make it generic enough to work with all the current micro-blogging options, but there is not enough manpower for that at the moment. The best I could do is fix the current Twitter network layer and then start looking at a way to split that.

Mitter 0.3.2 “I wonder how you’d take to working in a pocket calculator.” released

Mitter is a simple application to keep your Twitter status up-to-date and to see your friends updates. It aims to be simple and with a small requirement list, while supporting multiple different interfaces.

New in this version:

  • You can now connect using HTTPS.
  • The popup menu on a tweet now have a “Reply” option.
  • Changed the way we created the date fields, preventing some crashes on 64 bit machines.
  • Fixed a problem with replies in the Cmd interface.
  • The prompt in the Cmd interface is now updated properly.
  • Tweets can be deleted in the Cmd interface.