Archive for May, 2011


After a year of being part of the TWC undergraduate lab, my time is finally drawing to a close, since I will be graduating. One of my favorite parts was how much freedom I had in what areas and projects I worked on, which let me explore several different areas during my time here. In my first semester I worked with SPARQL queries, data visualization, and related ideas, which culminated in a filtered browser demonstration that I made for the ISWC 2010 conference, using ISWC 2010 data. This exploration was not just in the concepts, but also in the languages, where I jumped around and used several new languages, such as SPARQL, Python, and PHP.

During winter break and throughout this semester, I took a different approach and instead focused on a single project for the entire time, the Wine Agent application, which helps to demonstrate the capabilities of using ontologies and semantic reasoning in a real-life application to wine recommendations. In particular, I worked on primarily GUI work over the winter, getting the iPhone version of the Wine Agent to work well and render nicely on all iOS devices, including the iPad. As I continued this work into this semester, I worked on more actual functionality along with the GUI work, as well as working with the rest of the Wine Agent team on distributed reasoning and bluetooth connectivity near the start of the semester. Thanks to this project, I gained a lot of experience in using a Mac, Xcode, Objective-C, and even learned about subversion because of it.

One thing that I definitely suggest is to not just work in our undergrad office downstairs, but to also spend some time upstairs working in the kitchen, or inside of Patrick’s office upstairs. You meet a lot more of the people in the office, and the conversations in the upstairs office can be pretty entertaining, both of which show a lot more of the personality of the lab. I think this would be especially nice for new members, who no longer see the others in the lab weekly, but rather monthly. Also, those calzones were fantastic and should be at every undergrad meeting!

Anyhow, here’s a bunch of very short summaries. There were way too many smaller changes to talk about, especially since I’ve already blogged about them before, but I covered most of the major ones here.

The first thing I did was working on just getting things to look good on the iPad, since it all started out just as small as the iPhone, and didn’t rotate to boot. The first area I worked on was the social media window, and was my first experience with the horrible class known as MultiViewCell, home to a bug in nearly every iteration I did.

Possibly due to this very first set of changes when I was still totally new to Objective-C and Cocoa programming. Oops.

The next section I did was the changes to the description UI. This required a pretty complicated change to use a modal window view instead of the picker wheel. This led to all sorts of fun as I tried to get familiar with delegates, how navigation controllers worked, what modal views were and how to incorporate those, and how to get at the actual data inside of the application. This was extremely useful later, since these same changes became routine as I continued with similar changes and fixes.

On the other hand, I once again did something silly with the data here that ended up going unnoticed until today when Evan let me know that it came up at a test earlier this week. The issue was where the dish description UI was just pulling the wine properties, due to an ad-hoc fix I had done as part of this change, due to my inexperience with the codebase. I was getting much better at this point though.

Having moved from just editing a view to completely revamping a view, I then progressed to creating an entirely new view when I worked on the user preferences menu. This resulted in me doing a whole lot of trial-and-error with setting various properties and fiddling with the table view, and also got me a lot more experience with what the various functions did and were used for in the tableview, as I attempted to get all of the resizing, adding, removing, and more to work.

Continuing with the same view was getting the recommendations preferences to work, which involved me slowly picking through, figuring out, and parsing a ridiculous chain of variables in pairs in arrays in arrays in mutable arrays, or some nonsense like that. This was yet another exercise in how the delegates were worked, since several layers of them were required here, with extra logic needed to accommodate it as well. It also gave me a much clearer idea of how the actual data was being packaged up and passed around.

At that point, the entire Wine Agent team began working on ideas for a bluetooth implementation for distributed reasoning of group recommendations. The user interface, network connections, and test communications were finished, but this was eventually deferred to some later date due to the importance of getting the core functionality and user interfaces ready for a chain of demos and hoped-for big demo.

My first task when coming back off the bluetooth work was to create yet another completely new feature, the personal info editing. This went through several forms, and I revamped my original UI to the one in the screenshot, moving from the usual screen shifting navigation to the modal view, and also changing how everything was edited. The fields also went through several revisions. The main issue here was getting the text fields to work so that the user could input and save the fields, which I hadn’t done before, since I was mostly working with buttons doing behavior, not cells with editable text.

The biggest chunk of work this semester was probably the login screen, which needed to be recreated (it had once existed long ago, but was largely removed, gutted, or rendered entirely useless by new code). After fixing up the UI itself for the main screen, I created the UI for the create user function, since the old UI was apparently lost to the ether. More importantly, I needed to implement the network communication so that the user data could actually be initialized and saved on our server. I finally managed to complete this thanks to working alongside Evan, so that we could simultaneously work on both the server-side and client-side code to quickly debug and fix this. This had a lot of work in kind of obscure debugging, eventually needing us to work from both ends, and also had new experiences in fiddling with the keychain itself, in order to save the session data.

After the create user function was completed, the same process was applied to the user login. Just had to link up everything, do some debugging, and link the response up to the keychain. Along with all kinds of assorted debugging, since the team session went through it so fast.

Finally, I did some work in looking at the recommendation view, which I had actually made earlier, but was only able to test once the recommendation manager was finished by Evan, since I pull the data being displayed from there. It is still buggy currently, but is able to work well in certain cases.

Here’s my work summary for this week’s All-Hands meeting. This month was almost entirely finishing up the login system, with a little bit of continuing work on the viewing of the recommendations. The first part of the month was spend fixing up the various delegates for the network communication messages, getting them to send the correct messages and linking them up to the interface. Following that, a lot of work got done in a series of impromptu meetings with Evan so that both the client and server sides of the Wine Agent could be worked on together, resulting in much faster work.

The first thing to get finished was the functionality and behavior of the Create User option, which involved a lot of testing and fiddling with the server-side processing. Several UI issues were also addressed here, such as the behavior of the actual text fields and saving/sending of the contents correctly.

This led directly into finishing the login system, since a big delay for me was the inability to actually test my code without the ability to create a test user. This was resolved in much the same way as with user creation, with lots of testing, looking at the client and server debug logs, and fixing all sorts of little issues.

One of the key things we worked on for this was enabling for the user’s session data to be stored in the device keychain, allowing the user to not have to login every single time they came back to the application. Going along with that was, of course, linking together everything to allow for logouts as well. This actually led to some odd behavior resulting from an earlier change and the internal logic for checking the login status had to be revamped as well.

This huge rush of work was followed by me going through everything much more slowly, finding more corner cases that we missed in just getting everything to work, and fixing a whole bunch of minor issues resulting from repeating certain actions, such as logging in/out, different kinds of inputs, and combinations of valid/invalid logins. The biggest issue here was an issue with OWLInstance not correctly clearing itself between attempts, which resulted in valid logins not working after an invalid attempt, but was fixed pretty quickly.

The only non-login related work that I did this month was just in testing an earlier feature I had made, for viewing recommendations, which could only be tested now that Evan got the recommendation manager to the point where there was data available that my work could draw on. It doesn’t work quite the way we want, since it only populates after restaurant menus are opened, and has issues with not clearing previous ones, but it does display the recommendations perfectly once those conditions are met. We did several tests with this just to try to find what the existing behavior does and what issues occur, although we did not actually address them currently.