Current MS Students/Tristan Peters/CS 590
From CSWiki
Contents |
[edit] Jan 6 (week 1)
CS590 Weekly Log
During this past week, I spent considerable time wondering if I even know enough to do a master's thesis/project. After deciding that the only way I can decide if I know enough or not is just to try to start and see what happens, I began thinking about some areas I am interested in: -robotics and algorithms used in robot learning -video compression
I don't really know too much about these areas yet, so much of my early preparation will consist of learning the basics.
Another possibility for a project might be a touch screen database application that my wife mentioned is needed by the library where she works.
[edit] Jan 12 (week 2)
CS590 Weekly Log
This week I began looking at some of the areas I thought I might be interested in. I ordered a book about artificial intelligence, and began looking at some frameworks and libraries. I looked at the Java Annotations API and the Java Advanced Imaging library. I also talked more with my wife about the touch screen database needed by her library, which I though might be a possible project. Apparently, her library is in the process of reorganizing and modernizing its collection and would like to implement a touch screen system that would operate kind of like what we know on Windows as a "wizard" to help people find materials. The first screen displayed would be a list of categories of books. The user would select one, and then and list of subjects in the selected category would be selected. After a subject was selected, the search would be further narrowed based on different types of criteria (she didn't know exactly). The information about the books is apparently already in some kind of a database, but she didn't know what kind. Also, the library does not have the necessary touch screen hardware or have any idea how it would work.
[edit] Jan 19 (week 3)
CS590 Weekly Log This week I looked more extensively at the java advanced imaging API and figured out how it basically works, and how to do basic operations on an image such as rotate and warp. I read the introduction pages for some other libraries and frameworks to decide what will be the next one I look at and present to the class. I also thought of some more project ideas, though I am always wondering if they will be extensive enough for a master's project. There are a number of web sites these days that promise to donate money to some humanitarian cause every time a user clicks on a link to a page that features a bunch of advertisements. Most of these sites limit the number of clicks per user to one per day. I was thinking about a program that would allow a user to choose from a list of such sites and then automatically click on certain links on a user-defined schedule. That way more money would get donated to good causes without the user actually having to be at the computer to click a bunch of links. I realize that such a program would defeat the purpose of what the sites were trying to accomplish--getting people to look at banner ads, so I will have to consider whether such a project would be ethically sound. Also, I kind of think it might be too easy for a master's project. There are already programs that do similar things on websites such as those that bid automatically for users on auction sites, and some of these are open source so this might be a good place to start.
[edit] Jan 26 (week 4)
CS590 Weekly Log
This week I decided to look at the OWL Framework for Semantic Web. The idea of the Semantic Web is for web sites to process information more like people process information: by understanding the meaning of sentences rather than just searching for one or more words in phrases. In order for this to happen, computers must be taught to make connections between words. For instance, understanding the sentence, "The bird is eating crumbs off the ground." would require that the computer know what a bird is (an flying animal, having feathers, of small size compared to a human, etc), what eating means, what a crumb is, and what the ground is. In order to get a computer to understand all this, OWL seeks to define classes, subclasses, and rules to simulate human thought. For instance, we could say that a bird is a subclass of animals and also of things that fly. From this we know that a bird is a flying animal. ALso, if we know that all animals eat, then we would know that a bird eats. As I began looking at OWL, I realized that a thorough understanding of how it works would require an understanding of RDF, the Resource Description Framework. RDF is a language that is useful for defining connections between resources. Resources are defined as URIs (Uniform Resource Identifiers). A resource can be anything, a resource on the web, a product, a person, or anthying else. The idea of RDF is to provide a framework to allow people to define relationships between resources, much like a relational database does. Unlike a database, though, the resources in RDF do not need to be stored in a central location, but can be accessed from many different locations simultaneously. For instance, different companies might publish rdf files about their products, and then reviewers could access these files and link reviews to each of them. All of this could be done without a centralized database of either the products or the reviews.
RDF is a framework and OWL uses this framework to define connections between real world things. I prepared a simple example of rdf to present in class.
We didn't have time in class for me to present, so I will go into a little more detail about rdf as well as make a wiki page RDF for it.
RDF can use a number of syntaxes, 2 of which are n3 and xml. I started with n3 since I am relatively new to xml and heard that n3 was easier to understand. Basically, RDF describes things in terms of triples: a subject, predicate, and object. For instance, my cat's fur is grey. I can represent this in RDF as <http://things-in-my-house.com/cats#Cougar>(URI to represent my cat) c:furIs <http://some-colors.com#grey>.
Then, if somewhere the URI for the color grey has properties that it is close to the color silver, applications that use my rdf file will know that my cat's color is close to silver, without me having to explicitly say so. The URI for tjhe color grey may not have been created by me or even under my control. If my application can access it, then it will know that my cat's fur is close to silver.
I found and installed a program to interpret rdf files. It is called cwm. With it I can make deductions based on rdf files, merge rdf files, and convert from xml syntax to n3 syntax and vice versa. I will hopefully be able next week to show a simple example of deductions from rdf files using cwm.
[edit] Feb 2 (Week 5)
CS590 Weekly Log This week I looked more extensively at rdf and began to think seriously about what I will do my project on. In researching how to use rdf, I came across a vocabulary for rdf called Friend of a Friend (foaf). Foaf basically uses the rdf language to define tags that are appropriate for characterizing people and their blogs. The idea is to for people to publish rdf files using the foaf vocabulary and then for applications to parse the files and make links between the people and establish connections between them. I look at rdf as a way to make the entire web into a big database. If enough people use the same vocabulary then the effect will be a huge graph with connections made between all sorts of different resources. If enough people use foaf, then an application could potentially index a large amount of these documents and store connections between people based on interests, occupation, friends, etc. My idea for a project is to write a mobile application that uses foaf data to make connections between people and then uses cellphone gps technology to pinpoint friends of friends. I spent a lot of time this week playing around with rdf and foaf and trying to create queries with java code. To do this requires the jena framework and the sparql query language. I wrote a simple example of how to use jena to query rdf data using jena and I presented it in class.
[edit] Feb 9 (Week 6)
CS590 Weekly Log
This week I looked for foaf and rdf data on the internet to use for my project. I quickly discovered that the foaf framework is not very widespread. I decided that the core of my project idea really didn't depend on foaf, but rather the ability to use gps technology to locate friends. I decided that would be the crux of my project: a mobile application that tracks friends based on gps locations sent by their cell phones. I started researching whether it was possible to get GPS data from cell phones and if so, how it would be done. I found a site, mologogo.com, that has pretty much done the exact same thing I want to do. Their site allows users to sign up and download a program that runs on their phones. They can add other mologogo users as their friends, and once they have done so, the program on their phones will show a map with the pinpointed locations of their friends.
I thought a good project would be to simply reproduce the functionality of mologogo.
[edit] Feb 17 (Week 7)
This week I began looking at the J2ME library, which I will be using to build my mobile application. You cannot just write regular java code and expect it to run on a mobile device. Java enabled phones come with a small version of the JVM, but it is considerably different from the JVM on desktops. Because of this fact, development for mobile devices is considerably different than development for desktops. I made a couple of simple programs to get a feel for working with J2ME. Since my project requires internet connections from mobile devices, I decided that I would make a HelloWorld that demonstrated this capability. I made a servlet that counts the number of times a web page is accessed by a user and outputs this number on the web page. Using the J2ME library, I made an application that runs on a phone and accesses this servlet. My J2ME program runs inside of an emulator on a desktop. I plan on presenting this to thye class next week.
I met with Professor Miller to discuss my project. We decided that it would be better if, instead of simply reproducing the functionality of mologogo, I added some features to make it better. We both had some good ideas, and he suggested I write a couple of pages on them and put them into my prospectus.
