Almost two months ago, I wrote a blog post about Ta-da List. I wondered why it even took 600 lines to write if Ruby on Rails was as revolutionary as the authors claimed. Some people said that I had to back up my statements by implementing it myself in another technology, and that's what I did. The result can be seen at http://blablalist.com.
The implementation has been done in RIFE, Laszlo and Java. If you're interested, you can peruse the sources by going to the Subversion repository. I will be releasing packaged binary versions soon.
The application has 752 lines of Java code (empty lines, comments and imports removed) and 155 lines of XML code. This is only 300 lines more, while Java and XML are a lot more verbose than the Ruby language. It's certainly a lot less than the triple size that some people predicted. Now, let's leave the LoC wanking behind us.
Bla-bla List does a number of things differently and has some additional features:
- continue what you were doing when your session times out
update: Ta-da has been fixed to check the user's session for these operations. Of course when your sessions now times-out, your data is just lost. You don't get any warning message (which I hope they will at least fix in a later version).
Tada has solved this by removing the feature.
Ta-da list tricks you into thinking that this behavior is done securely. Most edit operations are actually performed without authentication. For instance, look at this URL http://tadalist.com/lists/public/1605. If you look at the HTML source code, you'll see the IDs of the entries.
Now, toggle the status on one of them (you can replace the 0 by a 1 at the end):
However, maybe you think that some things are missing, so why don't you add an entry:
You can mess up any Ta-da list like that! Just pick one out of the collection that you see here. I could make very nasty comments about this, but I'll keep this post civilized.
Bla-bla List ensures that all this is done securely and that you never lose data when your session times out. This is done thanks to an unique feature of RIFE that we call behavioural inheritance.
- secure private sharing
When sharing a list 'privately', Ta-da sends the invitees a non-protected URL. While they list this behavior as one of the features, I think that private lists should be secure at all times. I thus implemented a ticket system that adds shared lists to the invitees account through unique invitation URLs that can only be used once.
- customizable short names for public sharing
Ta-da generates non-intuitive public URLs that are beyond the user's control.
- fully functional REST API
- lists can be reordered
Ta-da simply doesn't allow you to do this.
- drag & drop to reorder entries and lists
Ta-da requires you to click awkward arrow buttons.
- automatic installation at first startup
Ta-da is not packaged nor distributed, but I doubt that the installation is part of its line count or even included in the source.
- the UI is designed to be small
Ta-da uses large fonts and takes up the whole browser window. I think it's important that the window can remain open without cluttering the desktop.
- only public RSS feeds
Ta-da has RSS feeds for all lists (private and public). Currently I only implemented the public version since I want to make the private one secure and I'm still doubting about what would be an acceptable way for users to do this.
Ta-da never showed their code nor released it under an open-source license.
Since I think that a number of people might prefer my implementation, I decided to host Bla-bla List myself in a similar fashion as Ta-da.
I'm quite interested in rich internet technologies and I'm planning on building a number of other client-side tools that communicate directly with the REST back-end. For instance: an Ajax and a Xul version of the current GUI, a MacOSX Tiger Dashboard widget, IDE plugins (IDEA, Eclipse, Netbeans), a Gnome applet, a mobile phone version, ...
This will make the application much more useful and provide an open-source comparison base for these technologies.
Have fun with Bla-bla!