The best part is that it runs on your desktop.

The good part is the range of functionality – real time ball-by-ball score updates, full scorecards, wagon-wheel and what not statistics, you can throw flowers or tomatoes at the cricketer of your choice and most of all, it pops up a GTalk-style notification for important events like a sixer, four or a batsman gets out!

The bad part is that the look and feel is too kiddish for my taste and the UI needs to be more simplified.

Back to the plus points, my favorite part is the mini-score card mode which will show up on the bottom-right corner of your desktop:

This idea was conceived and (as far as I know) executed entirely by Ramesh Srinivasaraghavan, Srinivas Annam, Arun Madas and many others in the Adobe Flex team in Bangalore. If this isn’t cool stuff happening in India dev centres, I don’t know what is. And what better way to show off AIR’s capabilities

I know they have had some tough times in convincing cricket websites about this idea, but it’s good to see it finally out.

I’ve spent the last six months staring at this page trying to figure out what to do. With some trepidation, I’m now turning to page 10. Thursday will be my last day at Vertigo. I will sorely miss the camaraderie and the many close personal friends I’ve made at Vertigo. Vertigo remains a fantastic place to work.

Sometimes choosing your own adventure means closing one door to open another. And I have to close the door on Vertigo, however reluctantly, to fully and wholeheartedly explore the alternatives. It would be unfair to Vertigo and to myself to do anything less. I’m not sure what exactly lies on page 10. I won’t lie to you. It’s scary to trade the security of a safe, salaried job for the unknowns. But the way I look at it, if it’s not a little scary, then it’s not the right choice. Failure is always an option.

Just s/Vertigo/Adobe/g and that’s my situation.

It was not an easy decision to make. Especially considering the people I work with. In fact, I squarely blame my Flex teammates Sreenivas, Sameer, Raghu, Harish, Harpreet, Kaashif, Anirudh, Sujit, Annam, Ram, Jyoti and so many others for making this such a difficult decision.

There are two incidents that have stuck in my mind for the past few days. One is the recent internal tech summit we had at Noida where Adobeans got to showcase each others’ technologies and ideas. Second, the (internal) showcase applications that our team created using our data visualization platform. I was simply blown away. The enthusiasm, the energy and the ideas was so addictive.

It seems strange that I should leave all this behind. It seems stranger that I have no clue where I’ll be six months from now. But yeah, I have some ideas.

As Ray Bradbury said:

If we listened to our intellect we’d never have a love affair. We’d never have a friendship. We’d never go in business because we’d be cynical: “It’s gonna go wrong.” Or “She’s going to hurt me.” Or, “I’ve had a couple of bad love affairs, so therefore …” Well, that’s nonsense. You’re going to miss life. You’ve got to jump off the cliff all the time and build your wings on the way down.

After working on the porting project to make Flex Builder run on Linux, I am starting to see why closed source software on Linux is hard.

There are just a handful of closed source products on Linux (counting only the famous ones) – Opera, Skype, Nero, Acrobat Reader, and Flash Player. Hmmm, I can think of just 5.

Why is that important at all? Because software developers who are not initiated to the FOSS philosophy will be scared off the platform because of its inherent complexities. For example, in this project, getting the software to run on the various Linux distros was, to put it lightly, troublesome.

There are a number of issues that we faced, which I’m certain is the reason others don’t want to get into this as well.

Let’s start with Eclipse. Eclipse runs fairly well on different platforms (let’s ignore the memory-hogging issue here), but on Linux, it’s a different ballgame. Somehow, the polishing of the UI is markedly lacking. Yes, we’ve filed bugs, but turns out it’s not really Eclipse’s fault, it’s simply because different window managers work differently on Linux, and handling all of this is a nightmare.

Oh, and this gets better when it comes to distros. For example, the latest released Eclipse 3.3 won’t run on the latest released Fedora version. You have to wait till Fedora 8! Because of this, we had to drop support for Fedora, and instead concentrated on other distros such as Suse, Red Hat and Ubuntu.

That brings up another problem – the number of distros. The QA effort required for the Flex Builder (FB) on Linux project was huge indeed. And yes, we found problems that occurred only on Red Hat but not on Ubuntu, and so on. For example, clicking on help links in Eclipse on Red Hat opens a new window every time whereas it properly displays in the same window on Ubuntu. Again, it’s not really Eclipse’s fault. Go figure.

Then, there’s the issue of running Firefox. There’s nothing wrong with Firefox itself, but what’s with each distro trying to customize the Firefox startup script?! FB on Linux has to check whether the correct version of the Flash Player plugin is installed in the browser, and checking this is a long procedure - do we check in ~/.firefox/plugins/ directory or ~/.mozilla/plugins/ or $MOZ_PLUGIN_PATH or some Suse-distro-specific directory such as /usr/lib/browser-plugins/!

Life is simply too hard compared to other operating systems.

Isn’t it a wonder that nobody wants to develop a closed source product for Linux? Even Microsoft is just handing over the audio video codecs to Novell and letting them to do the hard work of creating Moonlight on Linux. Microsoft is smart enough not to try to maintain a Linux version of Silverlight on its own (I’m considering only technical issues, let’s set aside philosophical issues on this one).

If we really want to make Linux a good platform, then we need to stop messing around with the basics – at least please don’t muck up the basic shell scripts and paths.

The way to get more people, in large numbers, to understand the open source and free software philosophies is by making their first steps easy. It cannot be an all-or-nothing approach. Closed source software on Linux is not practical. And that’s a bad thing because if we can’t convert software developers to use a different platform, how can we expect mom and pop to switch to Linux?

In spite of all this, I think we’ve done a good job of FB on Linux, and happy to see all the great response we’ve seen so far, including reports of success on various distros that we’ve never even heard before. So please keep the feedback coming!

Standard disclaimer: The opinions expressed here are my own, not Adobe’s.

The future direction of Flex Builder on Linux depends mostly on community feedback. Yes, seriously. So please do write in your feedback even if it is just “works well” or “it sucks”. Why is this important? The more the feedback, the more thought will be given to the product. This is how things work in Adobe (as far as I’ve seen). So again, voice your opinion on what you think of Flex Builder on Linux, and what you’d like to see and not see in it.

Disclosure: I am part of this project. I mostly handled the Linuxisms in the IDE functionality.

Update : Lots of feedback and comments (good to see that it’s mostly positive) on Digg, Slashdot and ZDNet. There’s also a video of the actual announcement put online by Peter Elst.

An example built using the AdvancedDataGrid is embedded below (it is a SWF file, requires Flash Player 9 for viewing):

Notice the tree view within a grid – that alone is a feature not found easily. On top of that, notice that there is a ‘total’ row in each of the categories of planets (click on the arrow to unfold a branch) – there are two aspects to this, first the summary (i.e. the total) is automatically calculated using a Collections API we have built, and secondly, you can specify a custom SummaryRenderer to display it any way you want, and in our case we are using column spanning so that it spans over the entire row. Now try doing that with your UI framework!

To understand what more you can do with AdvancedDataGrid, do read our writeup with lots of example code. Unfortunately, the live samples are not inline in the writeup (as we had originally written), you have to download them separately. You can also watch a video demonstration of AdvancedDataGrid. I hope this gives an inkling about the wide range of features and functionality in the AdvancedDataGrid.

Working on AdvancedDataGrid has been fun for me, mostly because of Sreenivas and Sameer, my teammates, who taught me most of what I have learnt about Flex.

And as someone commented on Ted’s post featuring AdvancedDataGrid:

OK, the workflow and the code enhancements were nice, but not enough to get me excited. But now I totally want to get my hands on that AdvancedDataGrid!

Gupshup seems to hit the sweet spot in the Indian context because its all about sms and mobile phones and combines it with the web. For example, you can start your own group and update your microblog via sms, and it’ll be automatically forwarded (as sms) to all those who subscribe to your channel. The posts are also available on a webpage. The added viral/social features are the ability to conduct your own polls or quizzes and even ratings.

I signed up for Gupshup and created my own microblog located at http://sms.webaroo.com/channels/Swaroop.

This got me thinking how people actually promote their microblog, and it turns out that one of the important things is a widget on their blog that points to the microblog, especially the Twitter badge.

So, I was looking for a widget for Gupshup as well but couldn’t find one. Why not write one myself?

It seemed pretty easy to create it using Flex because Gupshup now has RSS feeds. And just a hour and half of tinkering got me to create this:

I’ve put up the source MXML file for those interested. The tough work is handled by the <mx:HTTPService> tag which fetches the feed and outputs an XML which is easy to handle thanks to E4X. The rest is just housekeeping code.

Note that you’ll need your own proxy php script because of the security restrictions of the Flash player.

Somewhat relatedly, I got an invite to Popfly, thanks to Sriram, which helps anybody to create exactly these kind of widgets.

It turned out to be even easier to achieve it using Popfly:

1. Create a mashup
2. Click RSS block to add it to the main area
3. Edit to add the address of the RSS feed of your choice
4. Click News Reader block to add it to the main area
5. Connect the RSS block to the News Reader block
6. Click Save

You’re done. Here’s what you get:

Note that you might need Microsoft Silverlight installed to view this.

The upside is that it is ridiculously easy to create your own such mashups/widgets. The downside is that it is not easy to achieve the look and feel that you specifically want, it tends to all look the same (like the omnipresent Kubrick theme for Wordpress). For example, on my computer, the Popfly widget appears with scrollbars, and I can’t figure out how to get rid of the scrollbars.

About microblogging itself, I am not sure how long I’ll be into it, I’m just trying it out to see what’s all the fuss about.

This news was not so surprising to me because I’ve heard there have been lots and lots of discussions before on how to make Flex “open”. You have to keep in mind that a big company like Adobe is making transition from being a fully closed company to being more open – from the introduction of Adobe Labs to getting more open culture infused from Macromedia, to donating the ActionScript3 VM as open source to Mozilla, and now Flex. You can clearly see how this evolution is happening. Even the PDF format is going from a de-facto standard to a de-jure standard by the ISO organization.

Coming back to Flex, just some time ago I had noted how open Flex is, even source-open but not “open source”, we’re now taking the next big step and making even the code free. Awesome stuff.

I personally still think there’s one issue that needs to be addressed. There are two parts to the story – the production and consumption, which is, the creation and the playback. The creation part is now not just open but open source! Why not make the playback part open? If we can allow anyone to create a player that plays SWF formats, that would be great. Of course, if we make the Flash Player itself open source, that would be mind-blowing, but I think the minimum that should be done is to allow other SWF players in the market. Not that anybody can beat Flash Player (it’s very very hard)…

The news is still sinking in (it was announced just an hour ago, as of this writing). So, more coverage here:

• Official Adobe Press release
• Official FAQ
• Video interviews by Scoble
• Why now by Sho
• Podcast interview of Greg DeMichillie on Adobe vs Microsoft
• Writeup by Josh Tynjala

I couldn’t locate that app, so I had been wanting to write my own version for a long time and finally got around to doing it today.

It turned out to be easier than I thought. First, I had to figure out how to find out what application has the current focus at any point in time, and I was trying to see if I can do it from Python (using the Win32 extensions, and yes, this hack is Windows-only). After a lot of searching, I finally found out that it boils down to just one line: win32gui.GetWindowText(win32gui.GetForegroundWindow()) and this would fetch the title of the application that the user is using at that moment.

After this, all I had to was record the window title every 5 seconds and increment the time spent for each window, and voila, the data is ready. I was quite satisfied with just a command line output, but Raghu egged me on to create a Flex chart frontend for it as well, and when Harish joined in, the fun really got started. The first problem was how to push the data from Python to Flex, and we use the oldest trick in the book – write it to a file. Next, Flex can read the same file as long as the file is in the same directory as the SWF (i.e. the Flash file) location. Then we parse the text to get back the original data, create a pie chart and point it to this data, and voila we have a beautiful chart:

Now I can finally track what I actually end up doing the whole day, heh. You can download the files if you want to use it as well:

• The Python script called “BigBrother.py”
• The MXML file called “BigBrotherGUI.mxml”
• The compiled SWF file for those who don’t want to go through the hassle of compiling the MXML to SWF.
• Just run/open both BigBrother.py and BigBrotherGUI.swf at the same time and watch the statistics.

And who said meetings aren’t productive

Update:

1. Chris J Andrews made a JavaScript GUI frontend.

2. Theyagarajan modified the Python script to make it work on Linux.

Why this name? My reasoning was:

Ely liked the name ‘moxie’ a lot especially because of the way the fingers are evenly distributed across the keyboard when you type ‘moxie’ , and he championed the name which convinced the Flexers to vote for it.

This led me to say:

And Ted says Drink Moxie.

I was intrigued by this and did some homework.

Update : You may want to read the updated remarks at the end before reading the whole passage.

What is Flex?

Before we discuss licensing, it is important to be clear on what we are talking about.

For those who don’t know what Flex is – it is a framework to create interactive applications for the web.

• Framework : It consists of a language, libraries, tools (including compiler, debugger, IDE), client player – the whole works.

• Interactive : It is not a page-based model, it is more in the event-loop (GUI) model.

• Application : It is not suitable for putting up a few text pages. It is suitable for “applications” like the Sony Ericsson Online Store and many many more.

• Web : Flex applications are SWF files which run on the Flash Player, which is installed on almost all computers connected to the web today.

What are the parts of Flex?

There are two basic things we need to create a Flex application:

1. The Flash Player
2. The Flex SDK

Licensing of the Flash Player

We need the Flash Player installed to run the SWF files.

There are two sides to this:

(a) The SWF file format specification : The SWF file format is open in the sense anybody can freely download it but there is an important restriction:

“You may not use the Specification in any way to create or develop a runtime, client, player, executable or other program that reads or renders .swf files.”

This means that you can use the specification to write a program that exports to SWF but you cannot write a program that can play the SWF files.

(b) The Flash Player itself

The latest Adobe Flash Player 9 is available for Windows, Mac OS X, and recently for Linux as well. This is perhaps the only platform that truly is cross-platform and works well for a plugin that is just 1.1 MB in size. What else can claim to be installed on 98% of desktops connected to the Internet?

The Flash Player is not open source because it is one of the crown jewels for Adobe/Macromedia, and opening it might mean losing control? Is this situation similar to the Java open source debate?

Licensing of the Flex SDK

The Flex licensing was surprisingly short and to-the-point:

License Grant

Subject to the terms and conditions of this Agreement, Adobe grants Licensee a non-exclusive, nontransferable ilcense to

(a) use the SDK Components for the sole purpose of internally developing Developer Programs

(b) use the SDK Components as part of Licensee’s website for the sole purpose of compiling the Developer Programs that are distributed through the Licensee’s website

(c) modify and reproduce SDK source files for use as a component of Developer Programs that add Material Improvements to the SDK Source Files

(d) distribute SDK source files in object code form and/or source code form only as a component of Developer Programs that add Material Improvements to the SDK Source files, provided that

   (1) such Developer Programs are designed to operate in connection with the Adobe Flex Builder, Adobe Flex Charting, Adobe Flex Data Services Software, or the SDK Components

   (2) Licensee distributes such object code and/or source code under the terms and conditions of an EULA

   (3) Licensee includes a copyright notice reflecting the copyright ownership of Developer in such Developer Programs

   (4) Licensee shall be solely responsible to its customers for any update or support obligation or other liability which may arise from such distribution

   (5) Licensee does not make any statements that its Developer Program is “certified”, or that its performance is guaranteed, by Adobe

   (6) Licensee does not use Adobe’s name or trademarks to market its Developer Programs without written permission of Adobe

   (7) Licensee does not delete or in any manner alter the copyright notices, trademarks, logos or related notices, or other proprietary rights notices of Adobe (and its licensors, if any) appearing on or within the SDK Source Files and/or SDK Components, or any documentation relating to the SDK Components

   (8) Licensee causes any modified fields to carry prominent notices stating that Licensee changed the files

   (9) Licensee does not use “mx”, “mxml”, “flex”, “flash” or “adobe” in any new package or class names distributed with the SDK Source Files.

Any modified or merged portion of the SDK Source Files is subject to this Agreement.

Note: “Developer Programs” shall mean programs that are built consisting partly of the SDK Source Files and partly of user’s Material Improvement to add or extend the SDK Source Files.

Basically, Flex is as close to open source as it can get. It is already source-open i.e. the source is freely available. You can modify it and use it for your own purpose. If you want to redistribute it, then you are responsible for it (and not Adobe).

I think that’s a fairly open license, but does it satisfy the OSI criteria?:

1. Free redistribution – yes
2. Source code – yes
3. Derived works – yes
4. Integrity of the author’s source code – yes
5. No discrimination against persons or groups – yes
6. No discrimination against fields of endeavor – yes
7. Distribution of license – yes
8. License must not be specific to a product – no
9. License must not restrict other software – grey area (it’s in fact reverse, see (d)(1))
10. License must be technology-neutral – no

Disclaimer: IANAL. This is just my understanding.

I guess the only part where this license is not compatible with open source licenses is that this license is specific to Flex and is not a general license.

Big picture

It seems to me that Adobe’s business model around Flex is somewhat similar to Trolltech around Qt. Qt is free (as in GPL) for free projects and is commercial for commercial projects. Similarly, Flex (SDK) is free (as in ‘open’) for anybody who wants to use it but is paid for enterprises who want to do enterprise-level-kind of stuff (such as they need an IDE or need data services management or need charting components).

Let’s take a look at the stack again:

1. The Flash Player is ‘free as in beer’.

2. The Flex SDK has an open license.

3. The Flex Builder IDE, Flex Data Services and Flex Charting components are paid products. This is where Adobe makes its money. And Flex Builder IDE (based on Eclipse) is a very compelling product which really does make writing Flex applications easy.

I guess Adobe will never make the software fully open source, otherwise how will we ever make money? But I think in general, Adobe tries to strike “a good balance between what’s good for the community and what’s good for the shareholders”.

For example, you might have heard about Adobe’s contribution of the ActionScript VM(AVM2) to Mozilla under the project Tamarin. The possibilities of this announcement is enormous. AVM2 makes ActionScript 3 run 10 times faster than before, and Mozilla projects are mostly XUL and Javascript based, so imagine how many times faster it can run! (Note that ActionScript 3 and JavaScript 2 are both based on the same standard ECMAScript 4). The best part is that this is the core VM part of the Flash Player 9 and they will continue to share the same code base. Similarly, for Adobe, Actionscript gets broader adoption as well as more people can contribute to make the AVM2 better, faster, portable to more systems, etc. So, it’s a win-win situation.

Also, Apollo – that thing on which Adobe is betting its future on will be supported on Windows, Mac and Linux. From a presentation by Todd Hay:

“Q: Will Apollo run on Linux eventually as well? I’ve only heard Windows and Mac mentioned”

“A: Yes, absolutely. I don’t have the the date in front of me (laughs) when that’ll be available, but Linux is certainly one of the key platforms that we are targeting. Love to get feedback from the group on which distributions are most important to you, but for the first release in first part of next year, we expect to be supporting Linux as well.”

This is important because this gives Linux an equal footing with all platforms – developers can develop a single application and deploy on all the platforms without a single line of code change - the very promise of Java – ‘write once, run everywhere’, only in this case, it seems more feasible.

Overall, I think Adobe and Flex are poised in a good way, licensing wise, although there is room to be more open.

Regarding whether Flex itself will take off in a bigger way, well, Coenraets has already covered that.

Update :

Manish pointed out a couple of things:

1) I thought only the framework was “open”, not the entire SDK (which includes the tools–compiler, debugger, etc.). Am I right?

2) To what extent is the framework open? Can I modify the source files and redistribute it without Adobe’s permission, as long as “I am responsible for it (and not Adobe)”?

I think (1) is true in that the framework code is source-open but the tools are NOT.

I do not know the correct status of (2) since it was purely my interpretation of the licensing terms and I have not confirmed this with anyone.

Coming back to (1), I think that causes a lot of restrictions on how much Flex can be changed since a user can only use the tools and not modify them. This caused me to reconsider the openness of Flex – I think Flex is “not open enough”. Technology-wise, it has amazing capabilities but openness wise, I don’t think it can be really considered open.

I know I’ve been drawing a lot of flak for this post, but I think it was a necessary evil. Necessary because I needed some feedback on what I might have overlooked and this is exactly the kind of feedback that I got, which I’m happy about. To reiterate, this was about me trying to understanding the licensing and openness of the Flex sphere, and it was not really related to competitors.

Disclaimer : I work at Adobe, but these views are my own opinion, and do not represent any official position/interpretation.

Update : There are now beta versions of Flash Player 9 for Linux available from Adobe Labs to support Solaris on both x86 and Sparc CPU architectures.