For my Bachelor's Thesis, I worked with Prof. Sudarshan on query optimization techniques for parallel databases.

Here is my Stage 1 report, as well as slides from my talk.

Abstract of the report:

The advent of Big Data has led to the increasing use of parallel and distributed frameworks for data processing. The increasing need for Online Analytical Processsing (OLAP) queries has made it necessary for database systems to handle complex queries with minimal response times. Although query optimization has consistently shown significant performance gains for traditional database systems, the optimization of queries on parallel databases has a lot of room for improvement. It is evident that improvements in query optimization techniques will lead to substantial gains for parallel data frameworks. This report surveys the state-of-the-art in traditional query optimization, followed by a survey of recent parallel data frameworks. We present methods that have been used successfully in traditional database systems like duplicate- free join enumeration and pruning techniques, and present extensions that should be applicable in a parallel setting.

I am working with Prof. Ganesh Ramakrishnan, Ashish Kulkarni (PhD candidate at IITB) and Kanika Agarwal (2nd yr MTech at IITB) on the interesting problem of entity disambiguation for annotating unstructured web page text with Wikipedia entities. This is a well-researched problem with many good solution approaches in the literature. What we are trying is a holistic approach of performing collective disambiguation of entities, as against the per-mention disambiguation that is popular in the current research.

A live demo can be accessed here. (The link is internal to IITB campus.) If you are interested in knowing more about our progress, please contact me.

I presented a seminar on Semantic Web in the Artificial Intelligence course, with Darshan Kapashi and Hemant Gangolia. Here are the slides.

For my Embedded Systems Lab project, I worked with Darshan, Aditya and Siddhesh on a very cool project: building a Java interface for Android developers to control the Firebird 5 robot using Android apps.

We have developed an Android library app which provides an API to send commands and receive sensor values from the Firebird robot. It encapsulates the communication layer between the phone and the bot. The code is written in a modular way so that any communication channel can be used, depending on the hardware available. We have provided a driver for Bluetooth communication (using BlueLINK dongle) which is included in the library app. This can easily be replaced by drivers for Wireless, Zigbee, or any other communication channel.

We have developed a command interpreter in C which is to be run on the Firebird bot. The interpreter covers all possible functions of the Firebird, so that Android developers do not need to know Firebird C programming, as they can directly control the Firebird through the Android API.

Our goal is to create an ecosystem for Android developers to build apps that do novel and interesting things with the Firebird, without worrying about the intricate details about the hardware. We believe that there is immense potential in this approach. We have provided a few sample apps to show the power of our API. One is a simple controller interface (MissionControl), another is an automated bot-parking app (PeterParker), and the third and most involved one is a wall follower app (MapperBot) which makes the Firebird bot follow the walls of a room and maps out the room in real-time, showing a map of the room on the Android phone.

Our code is open source, and available on Github. Feel free to build upon this, and please do let us know of any interesting stuff that you do with it.

Here is the report we submitted, and slides from our presentation (which got us the perfect grade in the lab course!).

Here is a demo video of our project in action.

For my Database Systems course project, I worked with Siddhesh, Sagar, Hemant and Chinmay on building a news aggregator web application, using JSP server and HTML+JS frontend.

For my Convex Optimization course project, I studied Submodular Function Optimization.

For my Operating Systems Lab project, I worked with Aditya, Vihang, Chinmay and Hemant to build a Virtual Memory subsystem for the experimental Pranali operating system, which is based on GuestOS.

For my Networks Lab project, Darshan and I developed a multi-way chat program that allows group chats and reliable file sharing between users.

The interesting part of the project is that we were constrained (by the professor) to use only the UDP protocol for transfer of messages. So we implemented a lot of the TCP functionality for reliability over the UDP protocol.

In my first year of undergraduate study, in my first "real" computer science course (not counting the institute-wide CS 101), offered by Prof. Amitabha Sanyal, I worked individually on developing a web crawler and a search engine interface. All programming was done in Scheme (a dialect of Lisp). It was a great experience, for many reasons:

• It was my first try at building a full-fledged software application as complex as a search engine (as opposed to the Sudoku-solvers and similar programs I had hacked on prior to this)
• I had complete freedom in designing the software, which means I spent a lot of time thinking about various issues, and through associated research on the Web, I learnt many concepts like caching, hashing, crawlers and robots.txt, modular designs, etc. This undoubtedly gave me a headstart in the various CS courses I subsequently took, starting from my second year of study
• I worked individually on this project, while everyone else worked in a group. Which means, I had a lot of independence in planning and executing the project work. On the downside, I had to manage all parts of the project code base, write the reports, and do 10 other things. I quickly realised that hacking at some scripts on a lazy afternoon is best done individually; substantial software projects are not (and so have only worked in teams, invariably as the team leader, in all later course projects)
• Scheme!
• Prof. Sanyal gave me a perfect 100/100 for my project!

Read the initial project proposal that I prepared. Note the naivete exhibited by the novice me (not limited to the Comic Sans font), making ambitious claims: I basically proposed (without realizing) to build a Web-scale ontology coupled with an entity-relationship extraction system, single handedly and in a space of two months, with my freshman-level knowledge of computer science!

Here is the final report, submitted after completing a basic (working) search engine for the project (yet arguably still ambitious for a freshman, which should explain the 100/100 score). The report is a more mature document (I hope!) and details the final design of my search engine, plus my experiences along the way.

Here is the code, for the Lisp-literate among you.

This project was certainly a growing-up experience for me, as I came to terms with the gap between ambitious research goals (what I want) and the realities of software development (what is possible right now). It laid the seeds for my interest in AI, machine learning and data mining, which I have explored with "never-ending curiosity" ever since.

After that semester finished, I spent the summer wondering (and Googling) why it was so damn hard to build such an intelligent "focused search utility" :)

In the CS475: Computer Graphics elective, I did four assignments; the first one was on writing a turtle interpreter in C++, which takes ToyLOGO command file and draws the output using OpenGL.

Here is the report.

The other three assignments were three stages of building a 3D world and animating a WALL-E robot (nicknamed Small-E). Here are the three reports:

1. Part 1
2. Part 2
3. Part 3