Blogs

Howdy folks and welcome to another edition of the Summer of Code - Last year was really fun and I hope this year will be more!

This time I’ll be working with the wonderful folks at Plan 9 from Bell Labs on alternative implementations of the 9P protocol - a fundamental component of the Plan 9 operating system. The goal of the project is to provide a “Web-2.0ish” face to the 9P system and therefore has been codenamed “Web9″. A trac instance and subversion repository has been setup for the same.

I’ll start off with an OO-style PHP wrapper and then move onto a pure JavaScript implementation. Once that is done, a couple of applications showing off the new wrappers would make a great addition. Something like a FF extension to access 9P based filesystems (using the newly developed JS 9P implementations) would be fun

Looking forward to an awesome summer…

Been a while since my last blog post, and a lot has been happening. Somewhere around March, I became an official Gentoo Developer, which is totally awesome. Secondly, my proposal to Plan9 from Bell Labs was accepted for the Summer of Code this year. This year the ride was a bit more bumpy though; Google’s new methods of resolving duplicated acceptances almost got me orphaned. Anyway, all is well that ends well!

I’ll be doing some blogging relevant to the project at the same place as last year. If you’re tired of keeping track of so many feeds, use an aggregator or try out the feed from PlanetKiX; I just set it up to aggregate all my blog posts.

On other news, I played around a bit with OpenID, and it sounds really great. I got myself an OpenID at myOpenID and setup KiX to redirect OpenID authentication requests. Now, signing in to websites is as easy as typing www.kix.in; I wish more websites start supporting OpenID logins. Wordpress, are you listening?!

The all new Thunderbird 2.0 looks and feels great, but I’m getting the feeling that all changes are purely cosmetic. And what the hell is up with the intro screen trying to download the TB logo everytime I start it up? The super-glossy new-mail notifier is great though and I’m really beginning to enjoy it.

Well, final exams are approaching (they start next friday), and I can’t wait for them to get over. I have my work cut out for the summer and I’m really looking forward to it! In fact, so much that I almost forgot that I have to perform a compulsory 45-day internship during the period :-/

Later!

The deadline for SoC applications is almost over. And I’m in a dilemma as to how many applications I should really submit. I’m fairly confident on the ones I’ve sent so far, but the rest of the ideas are just too tempting. Especially this time around, Google did an excellent job of calling in a wide mix of organizations, all with fantastic ideas.

But Alas, you can’t have your cake and eat it too. From what I learnt last year, there’s no big point in sending in too many apps, even if you’re really excited about all of them - since you’ll only be doing one project in the end. I’ve decided not send in any more applications - even the fully prepared ones sitting on my hard disk: PHP (LiveDocs & XDebug Frontend), OpenSolaris (IPFiler/IKE GUI), MacPorts (GUI) and GWT (Vector Graphics API). An awful waste of carefully prepared proposals, but I think it’s for the best.

Sigh.

Well, the next thing to look forward to is the result announcement on the 11th. See you then!

Lately I’ve been spending some time on writing my SoC applications for this year’s edition. I’ve applied to 3 organizations so far, mainly because of the fear that just one application isn’t good enough to ensure a slot. A lot of students are frantic about how they must prepare their applications, and so I thought I’d give my 2 cents on the topic.

First off, relax. If there’s something I’ve learnt from last year, it’s the fact that if you’re really serious about the project you’re applying for, you have nothing to worry about. However, there are a small number of applications that are excellent in quality, but don’t make it because the organization doesn’t get as many slots. That place is not a good one to be in. So, it turns out that being excellent isn’t enough. You need to do better to make sure that you’re really on the top of the list.

Last year, I had applied to 6 organizations and 4 of those proposals were selected. In my opinion, all the 6 proposals had the same quality; they were all, after all, written by me and used the same “template”. So what was the reason for the 2 rejections? Gnome didn’t accept my proposal because my idea wasn’t very appealing to them - the proposal was great, but the project itself wasn’t something that was on their “priority list”. Portland State Univerisity didn’t accept my proposal because the idea was completey irrelevant to them - it even probably got marked as “spam”!

That means, the idea itself is as important as the application. To create a winning application, you first need a killer idea. I can safely assume that >80% of the applications selected last year were for ideas that were provided by the organization itself. Let’s face it, it’s difficult to come up with a killer idea that is *relevant* to the organization in question without being intimate with the organization beforehand. If you feel you’re not the creative type and you’re applying to an organization you haven’t been involved with before; play safe and go with one of the ideas posted on their ideas page. The mentors go through a lot of brainstorming to decide what ideas make it to that page. However, be warned that not all ideas may be really important to them: Gnome has divided their ideas page into three categories of decreasing priority.

Consequently, choosing a high-priority task also means that you’ll be facing stiff competition; and you’ll have to work extra hard to make your application stand out. But that’s what it takes to make a winning application. The organization is guranteed to pick their high-priority projects, unless there are *no* good applications for it (which is very unlikely), and that means the odds are higher here anyway.

Once you’ve chosen your idea, you need to sit down and write the application itself. Which, in my experience, just boils down to answering the 5 fundamental questions:

1) What? Be as detailed as you possibly can about what exactly you’re trying to do. Giving detailed explanations of what the problem at hand is all about, gives mentors the confidence that you know what you’re talking about. Some students have asked if they should start mentioning functions names or minute technical details; but in my opinion that’s a no-no. Detailed means a surface review of what problem you’ll be solving, or what feature you’ll be adding - not the exact technical details. In fact, in many proposals, figuring out those technical details may be a part of the project itself.

2) Why? If you’ve chosen a high-priority task, this answer should be easy. But it’s important to send a message to the organization justifying why this proposal is important to them, and how it would benefit them and the FOSS community in general. If you’re proposing one of your own ideas, this part is all the more important.

3) How? Here’s the part where you explain what your strategy for solving the problem is. Again, there’s no need to mention function prototypes or the nitty-gritty of implementation details; but you certainly must say enough to convince the mentors that you have the technical prowess required to complete the task at hand. As I’ve said before, in certain cases, working out these technical details is part of the proposal itself. In which case, include the various options that you intend to pursue. What happens if one of these options don’t work out quite right?

4) When? A timeline is an important part of any application. You don’t have to get it down to the date, but a rough outline in terms of weeks should be Ok too. Remember, mentors are looking for *quantitative* ways of measuring your progress. Give them milestones and spread out the project evenly across the given time. Also remember that this time around Google has given a whole month to get familiar with the project and working with infrastructure common to open source projects in general - So don’t say stuff like “Getting familiar with the codebase” or “Learn how to use CVS” in the coding time allotted. You need to do all that *before* you get down to business - on the 28th of May.

5) Why You? Summarize your application with a brief biography. Who you are and what makes you suitable for this project. You don’t need to repeat your whole resume here - certainly link to it - but be rather informal and focus on your *specific* skills or experience that are relevant to completing *this* project. The mentors can read your entire skillset in your resume anyway, use this space to convince them you’re the right one for this job instead. Give links to previous relevant work you’ve done. Show them you’re serious about this, and convince them that you will finish what you start.

A typical proposal is around 1000 words in length, 3 pages long maybe. Atleast mine are! Don’t be too brief nor too explanatory. The average amount of time a mentor will pay attention to your proposal is 2 minutes, so make sure your proposal can be read and understood in that time.

The applications I sent in last year are available here, and I’ll be posting this years soon. All the best, and most of all, Have Fun! FOSS is all about community and having fun, after all

I’ve managed to setup a proper development environment for Beacon, check it out here. All further developments related to Beacon will now happen on that Trac powered site

Meanwhile, keep an eye out for the next installment of the Summer of Code!

It’s that summery time of the year again. Yep, welcome the latest avatar of Google’s Summer of Code. All geared to be bigger and better than last year’s edition.

A whoppping 131 organizations have been selected this time around. Not many surprises; all the big fish like Apache, KDE, Gnome, Fedora, Debian, Gentoo, PHP, Python et. al. are mentoring organizations this year. However, there are also a lot of new interesting faces: Vim got a whole slot to itself and so did Git. Nice to see OpenSolaris joining the gang. Also looks like my efforts at canvassing the Macports team to sign up paid off, they’ve made it to the list too!

The webapp to handle all of the application process has been considerable spruced up for both the students and mentors. Also looks like mentors get an indication of students who are likely to accepted by multiple organizations. Too bad

All in all, a pretty great line up of organizations and an awesome time ahead. Students, get your thinking hats on and start writing your proposals: Deadline is 24th. All the best!

Here’s a depiction of what Randall Munroe thinks about Open Source:

Do check out the rest of his webcomic. I’ve loved every single one

UPDATE: It seems a couple of XKCD fans shipped a real katana to RMS:

RMS responded with a thank you email, signing off with: “I am not sure what to do with it, other then keep it near my bed”. Heh.

I’m having to use SystemC for a project involving simulation of Network-On-Chip applications. Turned out that it didn’t quite compile cleanly on my GNU/Linux machine:


sc_process_int.cpp: In member function ‘virtual void sc_core::sc_thread_process::prepare_for_simulation()’:
sc_process_int.cpp:441: error: ’sc_thread_cor_fn’ was not declared in this scope
sc_process_int.cpp: In member function ‘virtual void sc_core::sc_cthread_process::prepare_for_simulation()’:
sc_process_int.cpp:630: error: ’sc_cthread_cor_fn’ was not declared in this scope


My friend pointed me to a patch for this, which I later modified slightly. Turns out that GCC4 is a bit more stricter about friend functions than its old counterpart.

That problem solved, I went on to compiling SystemC on the Mac. My Macbook Pro has an Intel processor so it shouldn’t have been much trouble. Needless to say, configure couldn’t even detect the build type:


checking build system type… configure: error: cannot guess build type; you must specify one


And after specifying one explicitely:


$ ./configure –build=i386-pc-macosx configure: error: “sorry…architecture not supported”


Not a problem. After adding a case…esac block to configure.in (setting the CXXFLAGS etc. to the the same as the case for linux), we were up and running

In summary, here’s what you have to do after grabbing the SystemC sources (requires registration and acceptance of license):


$ tar xvzf systemc-2.1.v1.tgz
$ cd systemc-2.1.v1
$ wget \
http://www.kix.in/misc/patch_systemc-2.1.v1-gcc4-osx
$ patch -p0<patch_systemc-2.1.v1-gcc4-osx
$ autoconf
$ mkdir objdir
$ cd objdir
$ ../configure –build=i386-pc-macosx
$ make
$ make install
$ make check


Those of you trying to compile SystemC on GNU/Linux with GCC4 do the same; but leave out the `build’ argument to the configure statement.

ZOMG. Parallels‘ latest build brings along with it some nifty features. Which ultimately leads your desktop to look something like this:

No, that’s not some fabricated image made in GIMP. It’s for real; you can now run all the big 3 OSes side by side, just as if they’ve known each other for years

Here’s how you do it:

• Get yourself a powerful Intel Mac with 2Gigs of RAM (okay you may not really need this, but it’s always a good idea)
• Buy a copy of the latest Parallels Desktop. More than worth it!
• Install your favourite Linux Distro and Windows on two Parallels VM’s
• Or, if you already have BootCamp and want to use the native Windows already installed, Parallels allows you to boot from that too! I already had a native Windows running on Boot Camp, and I was up and running in no time with the useful guide you can find here
• Fire up the Linux VM, start the X server bundled with OS X. SSH to your Linux VM with X forwarding enabled, and start your favourite desktop: I chose XFCE, but Gnome/KDE will run equally well
• Fire up your Windows VM and enable the “Coherence” mode
• Start using Windows/OS X/Linux applications side by side, all within the comfort of your OS X desktop
• If you’re really insane create virtual machines for FreeBSD and Solaris too…

This has got to be the most coolest thing I’ve ever done with a computer

(In the screenshot: Windows Start menu just below the Apple menu; XFCE-Terminal on Linux; Safari on OS X; IE on Windows; XFCE-Panel (on Linux) just to the right of the OS X Dock. Windows applications even have their own Dock items; All Linux apps will be shown as only one X app though)

The batteries of my Macbook Pro suddenly swelled up today. I haven’t a clue in the world as to why it had to happen all of a sudden today but it did.

Maybe because I gave a hand at programming on the Mac for the first time today. We now have an installer for PHP-GTK. Intel Mac users only. Was also having a look at Metisse; sounds great. Anyone for a HCI research project?

LinuxAsia 2007, has Microsoft chipping in some funds and becoming the event’s “interoperability partner”. Excerpt from a recent article titled “MS takes linux world by storm” in the Economic Times:

When asked about its participation in Linux Asia, Microsoft said that the company will try to educate clients and communicate about its new stance towards open source. Mr Radhesh Balakrishnan, director, platform strategy, Microsoft, told ET, “Open source software is turning commercial and commercial software is becoming more open to open source. We believe that interoperability between the two is the way to the future. People have created a myth in the minds of clients that the world can work only either on open source. Rather than being carried over by rhetoric, clients should rather look at lowering TCO (total cost of ownership). According to a Frost & Sullivan study, Windows offers 15.9% lower TCO than Linux on the server side.”

Sigh, don’t we all love the TCO studies funded by Microsoft. Couple of people from there are also giving talks at LinuxAsia on stuff like “Exciting Technology Trends for Developers”. Wonder what the audience feels about that. I think a stall for adverstising “Wow with Vista” is on the cards too. Gee, what fun!

A friend of mine was recently called by the folks at Redmond for an internship; and he’s got “I HATE M$” all over his resume! Looks like Microsoft now wants a piece of the FOSS cake too. Way to go Ballmer, I just can’t wait for the Windows 95 source code to be released :-p

I just returned from Gnunify 07, and I have to say I had a great time in Pune. My talk went off quite well; although the audience count was low, it was a focussed group which is a good thing.

I couldn’t attend any of the other talks in the first day because I was also participating in the PHPThrowDown with Christian. Remind me never to mix two things ever again, Christian sums up how the whole thing went here.

On the second day however, I got to attend a lot of good talks, including those by Louis Potts from OpenOffice; Tony Wasserman from Carnegie Mellon, and Matt Barker from Canonical. The best thing I like about the conferences is that you get to meet a lot of people, and learn so much!

The volunteers for Gnunify were the most helpful lot I’ve ever seen anywhere, cheers to them! The airport security confiscated my spare batteries on my way to Pune, so I could take a few photos only on the next day; after I had some time to buy a new set. Ramakrishna, has a few more. Yet to find a comprehensive set of photos covering the event though.

On other news, Adobe opened up the PDF specs. w00t! We also launched the php-gtk-edge repository today; giving you bleeding-edge widgets for PHP-GTK. Think of it as a playground before extensions make it to php-gtk-proper. There’s also the official Indian channel for Gentoo users, #gentoo-in on Freenode; hope to see you there sometime

Until next post, keep smiling!

Okay, so we’re all done. Turns out Christian was online for the past three hours, and me for one; and we didn’t even know it. Sucky jabber presence protocols :-p

Christian summarizes the result:

“Okay, that was the worst competetion result ever. We only have 1/3rd of what we wanted”

I’ll take the entire blame on me. If it weren’t for the conference; we’d probably have done better since I would have been comfortable at home and dedicated a good 15 hours at the least to this. Ah well, as they say; the important thing is that we tried. Not much hope for a prize, but I guess we had good fun

And I learnt that you pass types to GtkListStore’s constructor; not numbers :-/

Yesterday wasn’t the luckiest of my days. I had absolutely no internet access once the conference was over; and so me and Christian had to quickly “split” the work so that each of us could work on it overnight.

It didn’t turn out quite that bad; but we still have to do the intergration of our components; and we’ve about 1 hour left.

So much for “live blogging”! I just hope we’re able to finish on time…

Turns out that PEAR is a real life-saver. We were able to use around 6 of them in our App, including three unreleased ones. Services_Blogging, PEAR_Config and Gtk2_ExceptionDump are absolutely essential to our application. No points for guessing what we are building! :-p

Christian made a mockup of the GUI in Glade, and I’m trying to implement that in pure PHP code. Chrisitian is hacking away on our Config framework and the account preferences GUI. System_Folders makes sure that our applications works like a charm on all platforms. We’re having decisions to make; like “To MDI or not to!”. Also on whether to use custom signals or go in for traditional signal handling. We’re more or less decided on no MDI and to use Event_SignalEmitter for all our handling needs.

Things are going good, especially considering I am also parallely attending Gnunify’ 07. Talk about multitasking, I love it

So, Christian and myself will be competing in PHP Throwdown this year. Obviously an application made in PHP-GTK.

Our start time was 06:00 UTC; and it’s now 1 and a half hours past. I’ve still only checked out the code from SVN (Christian had committed something in the morning), and I think we’ll get started now

We’re going to use Gobby for collaboration, and Christian’s Jabber and Teamspeak server is going to be a lot of help. More updates as they happen.

All the best to all those participating!

One of my new year resolutions was to use Mac OS X more often. I was very comfortable with my Gentoo installation; but spending $2800 on a Macbook Pro and then not using OS X is kind of stupid. I did try to “migrate” to the Mac several times in the past; but it never lasted more than 2 days. Gtk looked bad on the Mac, and GNU Parted wouldn’t run. Something or the other kept pulling me back to Linux (the latest reason was the ability to use Java 6). Well, the new year was a good opportunity to change my attitude and I decided to whole-heartedly attempt the move.

After 3 days of endless reboots; installations and configuration, I’m now the proud owner of what I’d like to call the “Macnix”

The first thing I did was to get myself a copy of Parallels. There really isn’t any other decent virtualization solution available for the Mac as of now; VMWare did release a beta but it’s really really slow. I ran through the Gentoo install process on a new Parallels virtual machine, taking care not to bloat the installation more than necessary. Gnome or KDE were definitely overkills; I decided to go in for the lean-and-mean XFCE instead. My laptop has 2 Gigs of RAM; so Parallels was doing good with the 512MB it was allotted.

As for equivalent applications for all my day-to-day tasks; I didn’t face any trouble at all; except the fact I had to compromise by using non-free software in some instances. Firefox and Thunderbird are available for OS X; migrating my old Thunderbird profile to the Mac installation was a no-brainer; as well as my old Firefox bookmarks. Although there’s no decent single application that could replace Gaim; the Adium + Colloquy combo delivers quite a punch. (Gaim does run on the Apple X11 server, but if you love your eyes you would never try that). Amarok was replaced by its original inspiration: iTunes, and F-Spot with iPhoto. Eclipse worked out-of-the-box and so did all the plugins (Thank God for JARs!). Azureus runs on OS X effortlessly.

On the command-line front; the Apple Terminal was seriously lacking; but iTerm proved to be an excellent replacement. After fiddling with the .bashrc a bit; I felt right at home with the classic Gentoo’ish colored BASH prompt. Okay, I still needed a lot more of the *nix stuff. There are only 2 good options you have here: Fink and MacPorts. A quick look at the different versions that they offered immediately shows that MacPorts is way ahead in terms of offering bleeding-edge version. And me being an avid Gentooer, MacPorts was the obvious choice

I had Gtk+ 2.10 up and running in no time, along with Python 2.5 and the wxPython bindings. That’s not all; I also got the latest and greatest versions of Apache 2 (OS X offers only httpd-1), PHP, Git, mySQL, PostgreSQL, SQLite and Subversion thanks to MacPorts. PHP-GTK also compiled without hitches. Although all Gtk apps looked really bad in the beginning, getting the gtk-engines2 and gtk-chtheme packages helped a lot.

One thing that really bugged me was the fact that I had to start the X11 server manually everytime I needed to run an X application; and the gross XTerm would appear. Thankfully, these tips helped a lot; X11 now starts automatically on login, no dock icon, no ugly XTerm; and I can run all my X applications from the comfort of the iTerm. I also made the VNCServer (I used TightVNC), mySQL, PostgreSQL and the Gentoo VM start automatically.

You ain’t seen nothing yet. After my Gentoo installation went of smoothly on the Parallels VM; I enabled for X11Forwarding enabled on both ends. Now I can all my Linux GUI applications, again from the comfort of the OS X environment and iTerm. Pick a decent Gtk theme; and it won’t even look bad!

The real icing on the cake is MacFUSE. The absolutely wonderful folks at Google ported the FUSE kernel module from Linux to Darwin. What does this mean? We can now write to NTFS (ntfs3g), mount SSHFS, CryptoFS, WebDAVFS and a dozen other filesystems in OS X. Sweet! I’m exploting sshfs to the fullest; OS X and Gentoo (on Parallels) share the same htdocs, home folders and distfiles.

All of this did take considerable amount of effort to setup though; ntfs3g wouldn’t compile cleanly; configuring X on Gentoo took quite a while; Getting Apache2 to integrate itself with OS X, stuff like that. Nothing that a search in Google couldn’t solve though. If any of you do have any trouble in installing any of the applications I’ve mentioned so far; I’d be glad to help. If you’re already a Linux Guru, you’ll face no trouble whatsoever

Ah, the perfect union of yin and yang. I think I’ve successfully migrated to OS X now; a whole day has passed and I haven’t missed my native Gentoo installation at all; and none of my work on Linux has been curbed thanks to all this amazing software. I love my Macnix!

(P.S.: I initially wanted to give detailed instructions on preparing this perfect “recipe” and also give some awesome screenshots, but I guess I’m too lazy for all that :-p)

Finally! VMWare has rolled out a beta version of its virtualization software for the OS X as promised, and its called Fusion (Beta). I’ve already used the Parallels Desktop on my Mac and it was good; but I know I can expect much more from VMWare

Here’s a list of features that VMWare claims to offer with Fusion:

• Create and run a wide variety of 32- and 64-bit x86 operating systems on OS X without rebooting. You can simultaneously run PC applications next to your OS X applications.
• Leverage Virtual SMP capabilities to gain additional performance improvements. On any Mac with dual-core processors, you can assign multiple CPUs to your virtual machine to gain additional performance for CPU-intensive workloads.
• Access physical devices from the virtual machine: read and burn CDs and DVDs, and use USB 2.0 devices like video cameras, iPods, printers, and disks at full speed. Even devices that do not have drivers for OS X will work in a virtual machine.
• Drag and drop files and folders between OS X and virtual machines to easily share data between the two environments!
• Leverage the cross-compatibility of VMware virtual machines. VMware virtual machines created with existing VMware products are all cross compatible, including virtual machines created by VMware Workstation, VMware Player, VMware Server and VMware Infrastructure 3.
• Run any of the 360 virtual appliances available from the Virtual Appliance Marketplace .

Downloading the 111MB DMG right now, can’t wait to try Gentoo on it!

Wow, been over a month since I last updated the blog. Somehow I just keep forgetting that I have one to update, even if there’s so much to tell!

FOSS.IN was organized to be held Nov 24th - 26th, and it was a resounding success. I wasn’t able to attend it (because of my final semester examinations) but from what I hear it was pretty good. Spending a little while on the #linux-india room of Freenode brought to my attention a certain controversy surrounding Atul Chitnis, a prominent FOSS evangelist in India. So if you want the grimy details; you should read this, this and this. I took up the issue with him on the Wikipedia talk page for FOSS.IN and as you’ll see; things are back to normal now

Christian got this nice idea of mapping PHP-GTK users on a map. The idea was soon extended to PEAR too and here’s the result. Talking of PHP-GTK, it seems that interest in the project has really grown. The number of people on the #php-gtk channel on Freenode now touched a double-digit number, and we now have our very own community site. PHP-GTK 2 even has a framework called Callicore for you to work with!

Linkblogs are turning out to be popular. Or as Wikipedia calls it, a Linklog. Considering I don’t maintain bookmarks (hell, I don’t even have digg account yet!); I don’t think I’ll maintain one, atleast in the near future.

The GNU Parted developer mailing list had some interesting discussions in the recent past. We also moved to using Git for version control, and it’s really fun to use! Debarshi Ray, a student from NIT Hamirpur (from what I could gather; they even have their own GLUG) made some useful contributions and earned himself commit rights. The project finally has enough developers to give it some momentum and all focus is on 2.0; codenamed “Edge”. I managed to get Trac up and running on Alioth so that we could have a Wiki, and it was simply hell. I’m still waiting for the Alioth admins to come and revoke my shell account

And now, for the eternal question. Is Flash evil? So it’s not an open standard and all, but I was very impressed with what Flex can do. As a web developer I think it’s a really promising platform for you to be building your web applications in. (Students: Have a look at Adobe India’s developer olympiad if you’re interested in Flex). If you’re a FOSS fanatic, have a look at OpenLaszlo; it’s pretty amazing too. Especially the fact that they’re working on a pure Javascript output in addition to traditional flash under “Project Legals”.

Stuart Herbert, my mentor during this years Summer of Code; announced his resignation to the Gentoo Council on 29th November. It was sad to see him go; but ah well. My new mentor for the Gentoo recruitment process is spb (also known as Stephen Bennett). It’s nice to work with him, and I’ve made it past the ebuild quiz. Got to get cracking on the end quiz, which isn’t as easy as the first one!

I’m right now in the beautiful campus of IIT Kanpur. I’ve come here to attend a 3-day workshop on algorithms for data streams; and I must say that 2 days into the workshop, I’ve already picked up so much. I’m lucky to be amongst the Crème de la Crème of the data streams scenario, and it’s been an amazing experience so far. I leave tomorrow, and shudder to think of the 40 hour train journey from New Delhi to Bangalore which I have to spend all alone!

Anyway, if you’re looking for something really funny to read (FOSS enthusiasts only!), you have to check out this webcomic. It’s a must read!

I guess that’s it for now. So until next time, keep smiling!

Phew! The FOSS workshop is finally over, and everything went off pretty much as planned, barring the few goofups that are just unavoidable in any event!

On 2nd night, we received the NRCFOSS team - Kenneth Gonsalves and Prof. C.N. Krishnan from the Jaipur airport, and while Prof. Krishnan went along with his old friend Prof. R. Sharan (who incidentally happened to be currently working at the LNMIIT at Jaipur!), we took Kenneth to the guest house here for dinner. The following morning was hectic as ever, we had to organize two events simultaneously - as luck would have it, the critical TEQIP feedback programme was also scheduled for 3rd!

So, we were kind of shuttling back and forth between the two venues. By around noon, we managed to wrap up the TEQIP programme, and turned our full attention to the FOSS workshop. Prof. Krishnan, Prof. Sharan and Kenneth first met with the Director and the faculty of our department to discuss the prospects of introducing FOSS awareness in our college. I didn’t attend that meeting (it was quite high profile), but I guess it was largely successful. Looks like the Director expressed interest in introducing this FOSS course as an elective for our department. Let’s see how that goes.

After this, all of us had lunch at the guest house, after which it was time for the student sessions. We managed to begin at around 2:15 despite several goofups. Kenneth took the first talk - an introduction to what FOSS is all about. This was followed by Prof. C.N. Krishnan talking about management and FOSS - as the director of the NRCFOSS at AU-KBC, he shared some of his experiences on how FOSS makes sense in the management and business context.

Meanwhile Raj Mathur, Prof. Andrew Lynn and Dr. Gora Mohanty - the team from ilugd - arrived, and after a short tea break, Raj Mathur began with his talk on FOSS philosophy, licensing and why FOSS is “good” - both ethically and monetarily. This was followed by a talk on Localisation and FOSS (with some great live demonstrations) by Dr. Gora. Prof. Andrew then took over with a brief (yeah, we were running out of time!) presentation on how you can use FOSS for research work such as cluster computing.

We winded up at around 7ish, after which everyone got together for a small brainstorming session where we discussed the further course of action, the proposed FOSS syllabi (see: FOSS and Education), and also debated on how this can be spread to other colleges in Rajasthan. By 8:15 we were all ready for Dinner. Unfortunately for Raj - we were heading for a vegetarian restaurant called “Indian Spice” - however, I think everyone still enjoyed the Gatta, Chacch and Missi Roti

The folks from Delhi were off to Banasthali from the restaruant itself, while the NRCFOSS folks stayed back because they were scheduled for talks at the LNMIIT on 4th. Overall, a successful event, and we hope the momentum is maintained in the coming years. We hope to have many more such events in the future, and pray that FOSS makes big strides in India!

[Some photos from the event here]

So, its been an exciting week. It seems like we really may be able to introduce a department elective on FOSS here in our college! We’re all set to get this in motion, and we’ve also invited people from NRCFOSS and ilugd to come over and talk to the students and faculty on what FOSS is all about, and why its worth having such a course in the curriculum.

I really hope this plan is successful; if it does, it definitely means a giant leap in the technical education scenario in India. Although some colleges under the Anna University already offer two electives designed by the NRCFOSS as part of the curriclum, none of the “biggies” of Anna University - CEG or MIT chose to offer it.

Our department already offers a rich set of electives, ranging from Neural networks to Robotics, which makes it difficult to offer two electives only on FOSS. It’s much easier for us to just offer a single crash-course type of elective on FOSS, and for this purpose, I modified the two-course syllabus created by the NRCFOSS a bit to get one tailor-made for our college. Check it out here, I’d love to hear some feedback on it.

Heh, if the course is accepted at the Senate meeting to be held in December; we may actually beat the IIT’s at offering this course. Mwhahaha

After a lot of hacking, I finally decided to release the next mini-version of Beacon. 0.2 has a lot of changes from the previous version; the most significant of them being a complete architectural change. Beacon 0.1 completely relied on JavaScript for most of the XML parsing; but I switched to PHP in this version. Hey, the server is bound to have more resources than the client, so the application is now a whole lot faster than before

I also finally got the DOM Tree to work. So now we have nice tree-like display of the GuideXML document. I’ll be adding DragAndDrop support to the tree itself sometime soon, but for now you have an easy of selecting and deleting Nodes (Chapters and Sections). Check out this screenshot:

Beacon 0.2 also using the Geshi Syntax highlighting engine to display the XML source instead of the earlier JavaScript engine. The XML is coloured on the server using PHP and subsequent changes are synchronizsed via AJAX calls:

Cheers!

I’ll be giving a talk on `Building web applications using Javascript’ on September 16th at Freedel. It’s my first talk, so I’m both nervous and excited! Anyway, if you happen to be anywhere near the NCR on 16th and 17th, do drop in. I’ll be focussing on the MochiKit and Dojo toolkits, both of which were extensively used to make Beacon, the GuideXML editor. I’ll also be offering some insight into how Beacon was built at the presentation.

Keep smiling!

Wow, time flies. The magnificent Summer of Code 2006 is finally nearing conclusion, with just a few more minutes to go.

Looking back at the entire experience, I cannot help but smile. Beginning from the proposal preparation, right upto the final moments of convincing your mentor that your project really deserves the last $2000 cheque; you keep feeling happy that you are part of something big.

I was especially lucky to be in the company of the totally awesome people at Gentoo, they made the whole thing a lot more enjoyable. One of the great things I liked about this years SoC program was how it brought so many different people from all corners of the world together; we got to interact with one helluva cross-section of folks

Thank you Google, and thank you Gentoo, for making this years summer one that I will remember for a long time to come! Looking forward to another great summer next year (maybe as a mentor? ;))

On another note, I’ll be trying to get Beacon to be officially accepted by the GDP. Which means lots more work to do, many improvements to be made. If Gentoo decides to retain the repository, I’ll continue developing on it there. Additionally, I wanted to be as generic as possible while building Beacon, which means that it has the capability of being an editor for almost any XML dialect. I’ll also be looking into those possibilities sometime in the future. Meanwhile, I’ll be working towards deploying both Beacon and repodoc-web on http://guidexml.soc.gentoo.org/, hopefully before next week.

As far as my other accepted applications are concerned, I’ve already begun work on the PHP-GNOME proposal. The other two would have to wait a while I guess

So, that’s it. Hope all of you have had a great summer! Cheers!

Update: Newer Screenshots
Phew! At last we have a working prototype of the GuideXML editor, and it’s called Beacon. Before we get bogged down with the technical details, lets have a look at the good stuff first

The welcome screen for Beacon is very simple, two options: Create new GuideXML document, or edit an existing one.

Once you’ve entered the essential details, you’re taken to the actual editor. It’s mostly based on Dojo’s InPlace Editor widget, but the more complicated tags like <p> and <pre> are handled by a textarea instead (basically, tags that can have more tags in them). Although they are just stupid textareas for now, watch out for shiny new RTEs like TinyMCE, they are bound to replace the textareas anytime in the near future!

With Beacon, you can even edit existing GuideXML documents with ease. Er, almost, don’t try editing the Gentoo Installation Handbook yet! (to be specific, <book> based GuideXML documents are not yet supported) But basically, everything remains the same as how it was when you create new document except that the content is already there.

Okay, the cool toolbox on the left allows you to drag and drop GuideXML elements on the document to add them. Dojo’s DnD kind of sucks, but MochiKit’s packed version doesn’t have DnD support yet…

…Now the problem is that you can’t remove elements yet. Lame, I know, but I guarantee that the space below the toolbox is reserved for the DOM tree of the document. That neat little widget will allow you to re-arrange or delete your GuideXML elements at will.

Neat. Now onto the gory details. The whole application is meant to be a generic XML editor, yeah, that’s right, Beacon is not entirely specific to GuideXML alone! Thanks to Dojo and MochiKit (both of whom still don’t like to talk to each other, I made them sit in the same room with great difficulty; Dojo wouldn’t let MochiKit in unless it was `packed’!) the entire application is driven by powerful XML configuration files that control all aspects of the application.

Beacon maintains dual representation of the document at all times; that means we have two DOM trees, one representing the GuideXML document itself, and the other representing the HTML (and editable) version of the document which you see in the `Design’ tab of the editor. Thanks to XSLT, interconversion is quick (I won’t say painless though, XSLT is TOUGH!).

Well, I better get back to making the editor look more beautiful while thinking about that DOM Tree widget… Meanwhile, you guys, enjoy!

So, it’s been a while since I posted anything, but that only means I’ve been in my coding hole all day all night

Lots of progress on the editor front, I finally got started on the UI and the AJAX backend. In priniciple, this is how it works: We have the welcome page which first asynchronously makes a request to the server for an XML file that contains everything needed to make the forms on the welcome page, essentially the fields that the `Create new File’  form requires. This may sound stupid, we already know what we need to create a new GuideXML document, but, I decided to take a more generic approach for two reasons:

• Easy Extensibility. What if there are changes to the GuideXML format itself?! This way, we also open up avenues for making a generic XML editor, not specific to GuideXML.
• Easy Translation. As mentioned in my proposal, I’m going to use the PO-file format to handle translations. Requesting for information at the very beginning allows me to get the strings to be displayed immediately.

True to the `AJAX’ concept, the PHP script returns an XML file (which is actually part of a larger `configuration’ file for the editor itself, more on that soon) which is then parsed by the friendly JavaScript and the form displayed to the user.

I’m going to be focussing on the creation of new documents at first, and so I’ve disabled the `Edit existing Document’ feature for now. So once the form for creating a new file has been filled, the JavaScript once again kicks into action and validates the form; if all is well, we submit the form to another PHP script that handles the initialization of the editor itself.

Coming on the editor, what we have here is a `Toolbox’ on the left with 3 menus and a tabbed pane on the right which acts as the editor itself. The first menu called `Primary Elements’ consists of buttons for modifying the Title, Author(s), Abstract, Version and Date of the GuideXML document. The second menu is called `Content Elements’ and has two buttons named `Chapter’ and `Section’. My plan is to be able to allow the user to simply drag-and-drop the Chapter/Section button to the editor, and, voila a Chapter/Section is inserted! Likewise with the 3rd menu called `Body Elements’, consisting of <p>, <pre>, <note>, <warn>, <impo>, <table>, <ul>, <ol>, <img> and <dl>.

In the editor area, every editable portion (title of the chapter/section, contents of any body element etc.) highlights when you move your cursor over it. Double-clicking it will open up a textbox (in cases of one-line contents or when formatting is not required/allowed, the chapter title for example) or a textarea (in cases where formatting is required, like the contents of any body element). Now the textarea is where TinyMCE kicks in, all textarea’s on the page will be replaced by a heavily-modified and stripped down version of TinyMCE that I am working on. Essentially, this WYSIWYG widget will allow you to format the text as <path>, <c>, <b>, <e>, <sub>, <sup>, <mail> and <uri> in the case of all body elements other than <pre>, and <i>, <comment>, <keyword>, <ident>, <const>, <stmt> and <var> in the case of pre-tags. Now this is kind of tough, I need to develop a plugin for each of these tags, the only functionality I can reuse from TinyMCE is the spellcheck plugin and the <sup>, <sub> tags.

Moving on to the backend, I was thinking of an XSLT file that translates the GuideXML source to a div-filled HTML format suitable for display in the editor and vice-versa. Actually we need two of these to convert from one format to another, the one to be used will be determined by the active tab; if the `View Source’ tab is active we convert the source to HTML, HTML to source otherwise.

Some knick-knacks to sort out would be stuff like how frequently the file should be saved, and how exactly that is to be done. All-in-all, pretty interesting stuff, please do have a look at the code in the SVN repository if you’re interested

So until next time, Cheers!

Stuart inspired me to do an objective evaluation of all the toolkits out there and then make a choice. So, here it is, my personal evaluation and reasons for choosing what I chose!

Okay, so that’s the brief summary. I haven’t included prototype in the list because its too fundamental and a lot of the toolkits are actually based on it. I also have probably missed many more toolkits, but these were the ones that caught my eye.

The main factors that we kept in mind while making the choice were:

• License. It is important for the toolkit to have an open license that falls within the limits of the Gentoo Social Contract.
• Infrastructure. The toolkits’ deployment requirements must be something that the Gentoo-Infra team can provide.
• Documentation. It shouldn’t take a long time to learn the toolkit itself. One of the important requirements of the project is rapid prototyping since the UI forms a core component of the editor.
• Stability & Support. The chosen toolkit should obviously not be one that is dead. It is important for the toolkit to be stable, and under active development; since the application may be used by hundreds of people.
• Features. Of course, the stuff that the toolkit offers should match with what we require. Ideally, it shouldn’t offer anything more nor less.

Based on the above, all Java based tollkits are out. The GWT has a particularly restrictive license. I wasn’t too comfortable YUI because it wouldn’t validate. I ruled out Dojo because it wouldn’t work in Opera. I am not too particular about the application working on IE, but I would expect it to work smoothly in Firefox and Opera at the very least. I started out with OpenRICO but then realised that I’m spending too much time finding out what functions it offers.

MochiKit offers most of the effects that script.aculo.us has, besides being one of the most awesome toolkits out there. One look at its documentation, and I knew this was it. It’s very programmer friendly, and work exactly like how you expect it too. MochiKit forms a very nice abstraction layer over JS to hide all the gory browser quirks. Its visual library however, is a bit broken, basic functions such as `Move’ or `Scale’ are broken, although they’re working on it for 1.4.

I couldn’t not use MochiKit just because of its Visual Effect backdraw, the other stuff that it offers are just too amazing too miss. So here’s where the X library comes in. I believe MochiKit and the X Library to perfectly complement each other; use MochiKit for the Model and Event Handling, while leaving X to do all the jazzy stuff. It’s working out quite well uptil now, although ideally I would prefer to use MochiKit alone (If only the `Move’ function would work!). But then, X is quite amazing too, and its fun to use both the toolkits.

So that’s that, I’m going to go ahead with MochiKit and the X Library. More on how the UI is going to turn out later.

(If you’re looking for the right AJAX toolkit to use for your application, I’d suggest you start your search with MochiKit. There are also good listings at OSAF and AJAX Patterns)

At long last, I have managed to create an ebuild for the repodoc web service and its sample client. This should help all interested Gentoo devs in installing it and giving us feedback. If your overlay is located at /usr/local/portage, you must first build the Manifest: `ebuild /usr/local/portage/www-apps/repodoc-web-0.0.1_alpha.ebuild digest’. After that, `emerge repodoc-web’ should do the trick.

But that’s not all. As the post-install instructions say, you must do two more things before you can start using the service.

1. Change the first 2 define lines in validate/index.php:
   define(’HTDOCS’, ‘/path/to/htdocs’);
   define(’REPODOC’, ‘/path/to/repodoc/executable’);Please note that the service will work well only with the latest GIT checkout of repodoc from Ferdy’s repository. The repodoc-0.0.1_beta ebuild will still work, although the output may not be as predicted as there are module changes between the ebuild and GIT versions.
2. You need to create the /.repodoc directory and assign its ownership to the web server (usually ‘apache’ or ‘nobody’). This step could not be included in the ebuild because of access violations. This is strictly a repodoc requirement and not related to the web-service. The repodoc team and myself will be working on a solution for this soon.

Once you’ve done these two steps, you may access the client at http://localhost/repodoc-web. Select a GuideXML file and click on Validate to get a tabulated result of the validation.

Now, I’d like to point out that the system is far from perfect. There are two basic issues that I need to tackle:

1. Eliminating the `modify define lines’ step since webapp.eclass knows the location of htdocs. Also repodoc is usually at /usr/bin/repodoc, but this is not entirely true if you’re not using the ebuild and just the GIT version.
2. Error Handling for non GuideXML files. Trying to validate a non GuideXML file will result in a non-helpful error message. Proper handling is necessary here.

Well, of course these aren’t the only flaws, so I’d love to hear about what you have to say about everything!

Building the ebuild was quite tricky, considering this is the first one I’ve made. The webapp and depend.php eclasses made things a little easier. The webapp eclass was nicely documented, and looking at other ebuilds like phpmyadmin or tikiwiki also helped quite a bit.

On other news, I was frantically trying to finalize on a particular AJAX toolkit. After further discussion with Stuart, who very kindly let me make the choice, it looks like we’ll go with Dojo. Although I’m not entirely sure yet. I’ve seen better eye-candy with Echo2, another Java based toolkit. Also, GWT is out because of licensing problems. Apparently, the license states that:

“you may not distribute Google Web Toolkit Development Tools or any services or software associated with or derived from them, or modify, copy, license, or create derivative works from Google Web Toolkit Development Tools, unless you obtain Google’s written permission in advance.”

Quite a day, I’m still undecided on the toolkit, but atleast I can sleep with the comfort of having written my first ebuild. Go Gentoo!

So, I’ve been pondering over how exactly the editor is going to be implemented. I’ve decided not to use any of the existing web-based WYSIWYG editors, but rather use one of the AJAX toolkits out there to build the whole application. I’ve narrowed it down to 3 choices, and here they are, in order of my preference:

1) Google Web Toolkit - Yep, it’s a Google product, so it should be quite fun to use! They have the good old swing-type widget concept here, so the main editor would consist of a custom widget that I will extend from the basic textarea. Yeah, if you notice, I will have to code in Java, which is not a problem for me at all. Before you arrive at any wrong conclusions, I would like to make it clear that GWT uses Java classes only as a base to generate code. The end-result is pure JavaScript + XHTML that can work with any server-side language (which in our case, is PHP). The advantages I see here are: support for a wide variety of browsers, a good solution for the triple-b (Browser Back Button) problem, and a robust framework to lean on.

2) Yahoo UI Library -  Ok, so I mentioned Google, it would be unfair not to mention the competition. The Yahoo UI library is damn stable and widely used (it’s not in “beta” like most of Google’s products!). Rich widget library, although building a custom editor widget here would be much tougher. Great effects, cool CSS and design patterns to go along. Pretty much everything to get the editor up and running.

3) Dojo - I don’t know why, but this reminds me of Django. Well Dojo uses the Moxie editor, which is to be modified to handle GuideXML instead of plain HTML. One thing that caught my eye here was the persistent storage functionality, that would allows users to temporarily save the document they are editing, on the server. I’m not sure we want that feature in the editor, but even otherwise, this toolkit is quite interesting.

Other than these 3, there is also Rico and Mochikit. This is the worst part about FLOSS, there’s just too much choice! Although my scales tip heavily towards the GWT ( this being the Google Summer of Code and all ); I plead all of you to please send me your opinion of what toolkit would be the best fit for the project.

Okay, so I got together a decent client for all of you to test out the repodoc web service. It's pretty basic, just about 35 lines of code, uses the cURL and XSL extensions of PHP5, and displays a tabulated page that shows how tha validation went. I haven't concentrated too much on the eye-candy yet, I'm waiting until I decide on a nice theme for the editor itself.

Check out the client, the upload form, and a sample result file.

Meanwhile, I'm steadily moving on the ebuild, it should be done now that the client is ready. I'm also going through "AJAX Patterns and Best Practices" to see which pattern applies to the editor the best. Needless to say, if any of you have ideas, comments, suggestions or cristicisms, be sure to send them my way

A brief update on what's been happening. So, according to my schedule, the web service is supposed to be all ready to go, which it is. So now onto the next phase, Interface Design. Interesting stuff, now this is where I get to design all the eye-candy and decide on how usable we want the editor to be

No surprises here, the good old XHTML + CSS + JavaScript combination can do wonders. I don't think I'll need to employ anything else to get a nice UI up and running. I'll have to keep in mind to keep the JS open enough for AJAX integration later on though.

But, before I get into that, Stuart wanted an ebuild for the repodoc web service. Which is an awesome idea, fits into the `Gentoo Way' (TM), besides making the installation for the web service a lot more generic and painless. My ebuilding skills are amateurish at best, but hey, I think I can pull it off. To begin with, the webapps.eclass should help immensely. The man page for that is quite informative, so I don't thnk I'll have any trouble here. OTOH, there is nothing much right now to package, just 3 files.The package would be a lot more substantial if I wrote a client for the web service and included that too. So I guess I'll do that before writing the ebuild.

And my totally awesome mentor has posted a blog entry on Mentoring SoC Participants! I'm very glad to be working with a mentor who puts so much thought into his work, thanks Stuart!

That's about it, stay tuned for updates on the ebuild and the UI. Cheers!