Jose M Vidal

Teaching Web Applications: github and youtube

2012-08-28T09:08:00.001-04:00

I am having my students use git and github for turning in their weekly project homeworks in my Web applications class this semester. The folks at github gave me 20 free private repos in our CSCE242 group which I am giving to the students, one each, so they can push their code without being able to see other students' code. The main goal is to get them familiarized, and maybe enthused, with git. A secondary goal is to make my grading easier. I hope to use github's commit commenting facilities to comment on specific lines of code in their code. Also, I'm setting up a cron job to git pull all the project locally right after the deadline, so then I can just open them up and run them, then maybe make some minor changes and push them upstream for the students to use.

I am also trying to flip the class, as I did in 145, by making youtube screencasts and assigning readings and then dedicating class time to one-on-one help with their ongoing project.

One interesting note is that the number of views on my Java tutorial videos did not go down after the semester was over but instead has stayed roughly the same over the Summer, as shown below. Perhaps this is a reflection of the current larger trend of 'everyone should learn to code'.

Constructive Network Formation Models

2012-06-14T11:24:00.003-04:00

Gary Fredericks recently presented a poster at AAMAS on our recent work on An Analysis of Constructive Network Formation Models.

This is really interesting theoretical work where we are looking at the possible topologies that can emerge given initial payment rules. For example, given a bunch of disconnected nodes (think ISPs before buying access to any other ISP, or businesses before establishing relationships with any other, etc.) and a rule that says that any link between two nodes has a fixed cost which must be paid by the two nodes in questions, but where everyone benefits from being closer (fewer edges between them) to everyone else, what kind of topologies will we expect to emerge if we let all agents build edges as they see fit?

We examine this problem in part by building graphs of graphs. That is, we built directed graphs, such as the one you see here, that show the possible evolution of these networks over time. From these we can then determine which topologies, or which features (small-world, small-diameter, etc.) are more likely given different initial rules of the game (equal payment for edge, one must pay, auctions, etc.)

Online Classes are Just the New Textbook

2012-05-03T16:05:00.000-04:00

About 4 years ago I started making videos for my students in 145: Intro to Programming class to watch. This semester I made 62 Java tutorial videos for them to watch. Their response has always been mostly positive: about half like them, the rest don't care, and the view logs show they are being watched, a lot.

This semester was the one where online programming classes really took off, with new startups like Audacity, Coursera, and CodeAcademy, all of them inspired by the now 11-year old MIT Open Courseware. These online courses are getting a lot of press because of reported hundred of thousands of students signing up. I told all my 145 students about these resources at the beginning of the semester, along with my own videos.

So, did the students learn more this semester than in past semesters? No. As evidenced by the in-class final, their proficiency at the end of class remains the same (I first taught this class in 2006).

I think videos are a great alternative way to present information, and the more different ways we can present the same idea to students the more likely we are to reach them. I will continue to use all these online resources in my own classes and continue to make my own videos, and I hope the videos get even better. But the fact remains that there is no teaching, there is only learning. That is, if one wants to learn how to code there is simply no alternative but to sit down and spend hours upon hours practicing (replace 'code' with 'play the guitar', 'do calculus', 'write well', 'play golf', etc). A teacher/book/onlinecourse cannot do the learning for you. The learning is all up to you.

Online classes like those from udemy and coursera attract those who are not in school (and, mostly outside the US) who have a deep desire to learn a specific topic (like, programming, to get a job). These people would have learned the subject by reading a book and practicing (just like I learned programming in high-school by reading a book and practicing with my Apple IIe). The online class just makes it a bit more pleasant, for some, and most importantly it is free. A textbook can easily cost you $100.

The ongoing challenge is not putting more courses online. That will happen, of course. All information is, or will soon be free. The challenge, and the job of Universities, is in guidance and certification. There is no way one person can learn everything so, what should he learn? Is it at the right level for the students in class? Most (all?) MIT and Stanford CS freshmen already know how to program, so their 101 class should be much different from ours. Then, can we certify that the student has indeed learned what he claims and not just outsourced his homework? It is trivial to cheat in an online class.

My 10-year old son is learning about percentages. I wish I could put him in front of some Khan Academy videos and have him do their practice exercises and, boom, he would be able to tell me if 10% off a $18 purchase is a better deal than 2 for the price of 1 at $15. I tried it. It didn't work. I still love the Khan Academy and we use it a lot, but it does not replace practice.

Web Applications Class, for Graduate Students

2012-03-17T09:58:00.000-04:00

I will be teaching CSCE 242: Web Applications again in the Fall. Go sign up, please!

Also, if you are a graduate student and want to take it come talk to me, we can probably work out that you can get CSCE 798 (directed study) for it. And, if you are a PhD student interested in doing a thesis related to web applications, online communities, or agent-based simulations (even better, all of these together!) come talk to me!

Interactive Quiz Web Application

2012-02-10T11:28:00.001-05:00

The video below is a short demo of a little webapp I developed for Julia Englund, Psychology Department, for giving interactive tests to (young) kids. The kids go to the website, take the tests, and their results are automatically sent back to the server. Julia designed the tests, I merely implemented the program. The app uses jQuery and the soundmanager.js library for handling sounds. It is an example of how one can build desktop-like interactive applications using javascript.

Java Tutorial Screencasts

2012-01-20T08:24:00.000-05:00

Back in 2009 I did a bunch of long screecasts to help my students in CSCE 145 learn to program in Java. They were well received but one complaint was that they were too long. This was also reflected in the logs as the number of views for the first video (first one in the semester) was very high but then decreased with each subsequent video.

In the mean time, the Kahn Academy has taught us that 10 minutes seems to be the magic number for online tutoring videos, after that people find it too unwieldily. Thus, I re-did all the videos for this semester. Now I have about 60 Java (and eclipse) tutorial videos. Youtube is gathering data on views. Let's see what happens.

iPad App for Taking Surveys

2011-06-12T08:52:00.001-04:00

I've been playing around with mobile webapps and JavaScript toolkits like Sencha touch and jQuery mobile. With all the news about native iphone apps, a lot of people forget that one can easily build iphone/ipad webapps that work offline and let you bypass the Apple store (so, no waiting weeks for approval, just upload it to your own website).

Dr. Jim Thrasher, from the Arnold School of Public Health, asked me to build an iPad app for his survey-administrators to use in administering surveys. The iPad is used to randomize questions and store all the survey answers, which are later uploaded to the server, when an Internet connection is available. The server is a google appengine web app.

Lessons learned:

Offline webapps are possible (almost too easy) on the iPad/iPhone. But, I had to train the users on how to clear the Safari cache whenever I put out a non backwards-compatible version.
A JavaScript toolkit like jQuery mobile or Sencha touch is needed for all its widgets. We need more widgets: this is probably the biggest current limitation.
My app auto-downloads and installs the latest version the moment it is run, kinda like Chrome, thus enabling a fast development cycle.

A Webapp for Turning in Programming Homeworks

2011-05-06T15:24:00.000-04:00

Since I had to grade about 20 programs every week and since these howeworks were webapps themselves that would be posted on some website that I could test, I figured that best way would be to have a pastebin-like app that allowed me to view all submitted homeworks. No such thing existed so I built one and called it i-am-done.

I used it last semester and it works very well. I allows one to:

create a class, and homeworks for it, giving each one a due date,
get a simple URL to give students for turning in programs for that homework,
view all the submitted howeworks for each student, in nicely colorized code thanks to prettify,
students can upload and delete any number of files associated with a particular homework but, of course, they can't see anyone else's homeworks.

It is like a paste-bin where only the person that created the class can see the code pasted under that class. I have placed the code here in case someone wants to make a fully featured system out of it. I would loooove to see that.

Web Applications: An Undergraduate Class

2011-05-06T05:30:00.003-04:00

Yet nother semester of teaching web application development has passed. This time, finally, I had a significant number of students (30) signing up although, after it became clear this was a programming class, fewer (17) remained. This is to be expected as programming takes time and not everyone has the means.

A few interesting tidbits I found.

Most undergraduates know little about web technologies. I kinda assumed that because they grew up with the web that they would know the difference between a GET and a POST, but no. There is a large knowledge gap to be filled in. Luckily, these are easy things for them to learn.
There is a steep learning curve to developing modern web applications, and it keeps getting steeper every year. A lot of complex technologies that must be mastered: HTTP, HMTL, CSS, JavaScript, Databases, Ajax, jQuery, JSON, Cookies, Firebug, functional programming, REST, event handling, asynchronous lambda functions, the browser's loading orders, etc. (oh, and Python) One semester is only enough time to introduce a student to most of these, but not all, and mastery will require more time spent programming than is afforded. Still, a lot can be learned in one semester.
I am sure some hated that we had 13 weekly homeworks, each one a significant programming project, but there really is no other way to learn all this stuff. It is one thing to read about Ajax, actually implementing a webapp that does it is a completely different matter.
Its all about the JavaScript: Facebook moved to a JavaScript SDK in their platform, Google is using JavaScript as glue to for their 'apps enterprise', and node.js has gotten really popular. With jquery and firebug (or chrome developer tools), JavaScript is a lot of fun to learn and debug. However, its tricky to figure out the timing on how various parts of a page are loaded by the browser and, even harder, how to decide what code goes in the server or the browser, not to mention JavaScript's many many quirks.
The google app engine works as a learning platform. It is minimal, reliable, and on the web (not on the student's laptop) so we all can see what we all have done.

Onward.

On Teaching Programming in the Age of the Web

2011-03-10T11:08:00.001-05:00

In the last few years a lot of people have been pushing the idea of 'flipping' the classroom experience: have the students view online videos as the homework then use class time for one-on-one help, see, for example, Kahn's video below. I agree it's a great idea, and there is data to support it, but can we do that when teaching programming to University students?

In the last couple of years I have tried to do this for two of my classes. My CSCE 145 is our introduction to programming class. It is taken by both computer majors and non-majors, about 50% for each group. My section alone had about 60 students. I created some Java programming videos which the students could watch at their leisure. With about 60 students, personalized in-class help was not possible, also because the classroom had no computers and the vast majority of students do not lug around a laptop all day with them. So, instead I decided to make the lectures more of an interactive demonstration: I would solve some programming problems in front of them and stop often ask them "how do you solve this?". The class also had a couple of weekly labs where the 60 students were broken up into more manageable groups and the TA's gave them individual help on the programming problems. I learned a couple of things.

The videos were watched by about 2/3 of the class. From the surveys I gather that the students that did not watch them where those who already had programming experience; they didn't need them. Thus, the videos were a success, mostly. Looking at the logs I see that the first video was watched the most, then the second one, and so on. So, some students stopped watching. I think I made the mistake of making them about 40mins long each (I wanted to cover 1 chapter in each video). Next time, I will follow Kahn's lead and keep them under 10 minutes and limit each one to more specific topics.
The lectures, in which I do a sample programming problem, seemed to be well received, but attendance was still just around 50% (students did not get penalized for not attending lecture). I think it would be more effective to get rid of lectures completely and have more labs, but this would mean I would have to spend 24 hours/week just in lab (12 hours/group with 2 groups of 30 students), so it becomes a significant time commitment. Add to that the time I spend making videos, tests, and homeworks and it quickly becomes 40 hours/week for just that one class. I think a more realistic solution is to pay some of our A-level Seniors to do some of that coaching, but we don't appear to have that kind of money right now.
IM works really well. If you to the class blog you will see the "Chat with Jose M Vidal" button. This, along with a pastebin were very useful. For whatever reason, students will not email me their questions, but they will hit me up on the IM. This was a great way to offer when-needed help. At this level students often get stuck with a simple problem, like a missing semicolon or a variable defined in the wrong scope. A student could spend hours trying to figure this out while I can just look at it and in two seconds solve this tiny bug so they can move on rather than giving up out of frustation, which is what many times happens (and then they drop out). With IM they could just send me their pastebin link and I could solve their problem, any time during the day. The only problem was that our schedules are rather off-sync: I sleep from 10-6am while they appear to sleep from 2--10am. Luckily, my TA was able to pick up the night shift.

In my CSCE 242 class I am teaching web applications which is a topic for which there are a lot of online instructional videos. The problem there is choosing which of these videos are good, and deciding on which ones to show at which time. Since this is a software development class, I structured as very heavy on the programming. The class consists of about 13 programming homeworks that, more or less, have the student build a modern complex web application. The class is not yet over, but already I see that:

IM has been even more useful in this class. I get at least a couple of question every day.
The best help is context-sensitive. Complex programming ideas are easier learned in context. When I grade one of the homeworks and I tell the student "I see how you did this, and it works fine, but look at this other way of doing it. Isn't it soo much simpler?" the lesson is readily learned. At least, that's how it seems to me. I wish I could get some data on this.

Going forward I hope more people like Kahn step up and produce more of these videos. In fact, I want to see better videos with animations, professional voice-overs, professional writers, etc. These videos will be our new Public Library. They will allow me to focus on proving the context-sensitive help that students need. I also see that teaching will continue to move away from 9-5 and become more of a 24/7 on-call type of job. Hopefully, we will have shifts!

Sending Emails from a Google Spreadsheet

2010-12-28T09:53:00.011-05:00

I have been using Google Spreadsheet to keep my class grades for a couple of years. It has several advantages over the PC version:

I can share the spreadsheet with my TAs so they can enter grades for their labs. We are all always on the same page.
Google spreadsheet keeps track of all old revisions, so if any one of us makes a mistake we can always go back to see what the original grade was.
It is trivially easy to create a graph of the grades and post a link to it on the class blog. The graph gets updated automatically as the grades change.

However, one remaining problem was how to give each student his grades without revealing all the grades, which our university frowns upon, even if the names are not posted. The clear answer is to email each student his own grade.

Luckily, Google has a cool feature called Google Apps Script which lets one write JavaScript programs that can access the data on a Google doc and do things like send emails. So, I wrote a short program to automatically send each student his grades.

Installation

To use it you must first set up your grades spreadsheet to look like this one. Note that

the first row has a 'name', 'email' and other columns for each item,
some columns have the same name as other columns, but with ' Comment' appended, for example: 'Test 1' and 'Test 1 Comment', the comment columns contain any comments you want to give the student
the sheets are named 'grades' and 'template'
the 'template' sheet contains the template information for building the emails (your message).

Once you have the spreadsheet built, go to 'Tools -> Scripts -> Scripts Editor and cut-and-paste the emailgrades.js script in there. Save it, then close and re-open the spreadsheet (or, run the onOpen method if you know how to do that). You should now see a new menu item on you spreadsheet called 'Class', as shown in the screenshot.

Usage

The 'Send Emails' item will send each student (row) his grades if you choose it when you have no cells selected. If you first select (light blue background box) some cells in the spreadsheet then it will only email the students in the selected rows. You can verify that the emails have been sent by going into your gmail account and checking the 'Sent Mail' folder. It can take several minutes for the emails to start appearing so be patient.

The 'Preview Emails' item is mostly for debugging. It will show you a preview of two of the emails that send emails would send. The 'Show Email Quota' item tells you how many more emails you can send today. Google limits scripts to 500 emails per day to keep spammers from abusing the system. Since my classes have at most 60 students this has not been a problem for me.

If you have any comments, bug reports, or feature requests please post them below.

Resiliency in Supply Chain Networks

2010-06-18T08:34:00.000-04:00

Andrew Smith and I have been looking at the problem of resiliency in supply chain networks. That is, given the fact that supply chains are formed by selfish agents who create links with others based on their own local interests, we cannot expect the resulting network to always have the optimal resiliency characteristics. It is quite possible that because everyone is acting myopically—agents care only about their immediate neighbors—that the resulting network will have some bad global properties. The global property Andrew studies first is resiliency, which we define as the ability of the network to withstand the loss of one node.

Andrew presented his paper titled A Practical Multiagent Model for Resilience in Commercial Supply Networks at the latest Agent-Mediated Electronic Conference. He implements a model which generates supply chain networks based on a well-known model from management theory, so the networks' topology should match real world networks, and then examines the resiliency of the resulting networks. The results are not surprising in the general sense (more connections mean more resiliency) but they do give us a quantitative measure of network resiliency.

Below are the slides from his presentation:

Software Engineering Projects

2010-05-14T22:24:00.000-04:00

I am often surprised at what a small group of our Senior Computer majors can accomplish in one semester, while taking four other classes, looking for a full time job and, in many cases, also working a part time job. But, they do some pretty amazing things in my CSCE 492 class.

The first group this semester decided to build an iphone app. None of them had any experience with the Mac, or objective-C, or the xcode IDE, nor did any one of them even own a Mac! Still, none of this matters much. They quickly came up to speed on objective-C (which has similarities to many of the languages they learned in other classes) and managed to build a game that is better than many of the games in the app store. I expect their skills will be much in demand. In fact, I know they are.

The second group built a Ruby on Rails applications that interfaced with the Amazon and the Facebook API's and used mysql, jQuery and had other javascript niceties. Only one of the students had experience with Ruby on Rails, and none had used web APIs before. It was another large learning and doing experience.

Still, aside from the technical knowledge they acquired, what they always tell me they learned most is how to work in a team and coordinate their time so as to get large projects like these done. That is not something that can be learned in a lecture.

SeaPort Container Terminal Simulation

2010-05-07T15:20:00.005-04:00

Next week I will be presenting our (with Nathan Huynh) paper on agent-based seaport container terminal simulation at the workshop on agents in traffic and transportation.

Basically, we used netlogo to build a simulation of a container seaport terminal, like the one you see on the photo. We focused only on the decision-making process of the cranes. Those large cranes you see have to pick up the containers and place them on the trucks as they arrive. Since the cranes are slow and there are many trucks the crane operators have to trade-off several competing interests when making their decision: trucks want to get out of there as quickly as possible, it takes the crane a long time to travel the length of the seaport, the port manager wants to maximize the number of trucks served but without making any one truck wait too long.

In this paper we tried the more obvious utility functions to see how they performed in a seaport with 2 or 3 cranes. The utility functions used are:

distance-based: roughly, go to the nearest truck, but avoid getting on the way of the other cranes,
time-based: roughly, serve the trucks on a first-come first-serve based, while trying to stay out of the way of other cranes,
a mixture of the above two.

Test results showed that the distance-based won, by a lot. It won not only on the throughput, as it obviously would, but also on the fairness measures, which is not so obvious.

I'll be putting up the netlogo model on my MAS Netlogo models page soon. The slides from the talk I'll deliver on Tuesday are below:

We are currently working on expanding this model, both from a programming, simulate more parts of the supply chain, and the analysis side, put some bounds on the solution quality that can be achieved assuming local control and local information.

What We Should Teach IT Students

2010-04-17T13:45:00.001-04:00

Yesterday I attended POSSCON where I saw a talk by Andy Lester on "What We Should Teach IT Students". As the use of the word IT in the title reveals, the target audience for the talk was enterprise developers.

For readers new to the field, enterprise developer is just a type of job. The easiest way to define the term is by pointing out that Blue Cross Blue Shield and Bank of America hire "enterprise developers" while Google, Microsoft, and Valve hire "software engineers". That is, enterprise developers write the software that makes the business run smoothly—process insurance claims—while developers write the software that IS the business—the new version of Windows. From an accounting point of view, enterprise developers are often a cost center for the company while developers are a profit center.

Still, the recommendations are largely applicable to all. He recommends students learn:

Source control
Bug tracking
Compiler (paying attention to the error messages)
Make and the philosophy of repeatability
Lint / splint or similar static code analyzers
Serious editing
DRY: Don't Repeat Yourself
Defensive programming
Maintenance: working on other people's code
Manual testing
Automated testing
Efficiency and why it does not matter
Thinking about the: business, project, release, deadline (getting the bigger picture)
Teamwork: work well with others

Our curriculum covers all of these, some more than others, and I am in full agreement with all of them.

Some of these, however, I think must be left mostly to the student. I know that learning to use the editor is super important, but I don't think we need an actual class to teach editing! I really can't see myself standing in front of our students for a whole semester telling them "To compile your code, press F8; to indent your code press Ctrl-A then Crtl-I". They know they can just get the list of shortcuts and memorize the ones they need. Still, I do make a point in my classes to stop and explain how I got System.out.println to appear after just typing sysout. Similarly, learning to use a source control or bug tracking system is just not that hard (compared with, say, implementing a compiler). Overall, the students who have not learned to use their editor, or understand compiler errors, or DRY, are generally the few who really don't care about programming, and their grades show it.

Still, I agree that these are all important skills to have.

Andy also said all students should have read Code Complete, which is the required textbook for my 492 class. He also mentioned The Pragmatic Programmer which is also a personal favorite of mine and on my list of recommended books for 492. Of course, we all know they are good because stackoverflow says they are.

Multiagent Systems Introduction

2010-04-05T17:50:00.002-04:00

Last week it was my pleasure to give an invited talk at Temple University, part of their Robert M. and Mary Haythornthwaite Foundation Distinguished Lecture Series. I tried to provide a high-level overview of multiagent systems is all about, which is always a huge challenge as the field covers a lot of disparate areas. After some thought, I decided to pick three applications and

describe all the issues relevant to the problem,
show how we use theory (either algorithms, game theory, or Economics) to get a better understanding of the underlying issues,
explain how there is still much engineering that needs to be done because even the best theory or algorithm still millions of details, and software is just a collection of details.

For posterity sake, below are the slides I used. The slides contain as little text as possible, which I think generally makes for a better talk.

Learning Java Videos

2010-02-23T18:02:00.003-05:00

Last semester I taught CSCE 145, our introduction to Java programming class. For that class I created a set of videos that teach the basics of Java programming using Eclipse as an IDE. The videos were very popular with students, especially those really new to programming. So, if you are a student interested in learning to program, go check them out.

CSCE 145: Chapter 1: Introduction to Java from Jose Vidal on Vimeo.

Current Research Talk

2010-02-17T13:14:00.000-05:00

This Friday at 2:30pm in 300 S. Main B102 I will be given an informal talk about our current research projects for our CSCE 791 class. This is open to anyone else who is interested. It will be a long rambling and highly disorganized version of my previous 7 minute talk.

Ongoing Research Projects

2009-11-13T14:30:00.083-05:00

Every year our department has 7-minute madness presentations in which we faculty present our ongoing research. It is a great opportunity to hear about all the innovative research going on in our department (especially in the area of multiagent systems, of course :-). The slides from my 7-minute talk are below.

For those of you who could not make it, and since I ran out of time after just a couple of slides, I write a bit about each project below.

We have a lot of papers published on distributed combinatorial auctions, especially on bidding algorithms for the PAUSE auction. This work was done with Benito Mendoza who received his PhD in May and is now working at Exxon on multiagent simulations. I continue to work on this topic but with a slightly different focus: viewing these distributed auctions as negotiation networks.

The iCoach project is with prof. Sara Wilcox from the department of exercise science. Chuck Burris, and undergraduate, has been developing on the Google App Engine a webapp that will send customized SMS messages to users by first gathering information from the user's phone, pedometer, and online information (where he is, via GPS, how much he has moved, via pedomenter or accelerometer, what his plans are, via his google calendar, etc.). There is a lot of information about us on the net, and the new smartphones will give us even more. However, aside from collecting and displaying this information back to the user in a pretty graph, there has been very little research done in to how to use this information to improve our lives. That is what we study. Our initial system is being designed to monitor, educate, and coach first-time pregnant women.

The wikitheoria is another Google App Engine webapp we are building, and by "we" I mean Jon Mayhak and Jason Rikard. The project is with prof. Barry Markovsky from the Sociology department and can be summarized as "wikepdia meets stackoverflow for sociologists, with added semantic structure". Our goal is to build a site that will enable and encourage sociologists to post their models using a common ontology (set of terms with agreed-upon definitions). The common ontology will also be developed on the site. The current site is currently being tested by forcing a graduate class of sociologists to use it.

The port simulation project is very new and its joint work with prof. Nathan Huynh from the department of Civil Engineering. Nathan is an expert in ports and trucking problems. In our initial collaboration we are looking at the problem of how the crane operators in a port should act or cooperate. The job of a crane operator is to pick up those big containers, one at a time, and put them on the trucks as the trucks arrive. The containers can be stacked up so sometimes the crane operators have to do some re-stacking of the containers, which wastes a lot of time. We are building an agent-based simulation of this problem and trying to find best strategies for the operators.

Andrew Smith is a new PhD student who has already written a paper on supply chain resiliency. Using standard models of supply-chain formation we generated sample chains and then tested these topologies for resiliency to single-point attacks. That is, if one node goes down how does that affect the network as a whole. In the paper (not yet published) we present a numerical measure of resiliency and our test results show how it varies given the number of relationship resources (a measure of sociability) and size.

Andrew is also continuing his work with Karim Mahrous from Sandia National Labs on media dispersion and influence as part of his PhD thesis. This is another agent-based modeling project, albeit a much larger one for which we only have to develop small parts of the code, which aims to model how news travels in a social network. The project will cover everything from broadcast media, to multicast media (twitter), to one-on-one via electronic (SMS) or good ol fashioned conversations over lunch.

So, if you are a graduate student and find these ideas interesting, you can sign up for my Multiagent Systems class in the Spring which will cover the basic background knowledge needed to build, and understand, multiagent systems. If you are from a funding agency or company with a few bucks to spare for research, I would love to hear from you!

Capstone Projects

2009-10-26T20:44:00.002-04:00

A blog post by Joel Spolsky on Capstone projects complains about how many of the top CS departments do not teach their students how to write large programs or how to work in large teams. Perhaps.

Here at the University of South Carolina, I created our CSCE 492 back in 2000 to address these problems. 492 is our capstone software project whose main goals, as I see them, are to:

Give the students the experience of working in a large (100 pages of code or more) software project.
Give them the experience of working in a group.

Our 492 projects are definitely not the type of project that can be finished in one or two days. They are much more significant than that. Still, on my first few years teaching it I learned that students do tend to postpone work until the last month. Thus, I have established certain guidelines.

Each group has a weekly meeting with me. In these meetings they give me their progress report and I keep track of of how much has and has not been achieved. We also set priorities for the next few weeks. Lack of progress is duly reprimanded, as any manager would do.

At the midterm there is an integration demo. Modern programs include several number of third-party libraries, from web frameworks to 3D engines, depending on the type of program being built. Students tend to underestimate how long it will take to install apache, mysql, mod_perl, library-X, put it all into svn, and get all that mess of code to say "Hello world" reliably. The integration demo is a proof-of-concept milestone which assures all of us that yes, this can work. After the demo all that is left to do is add all the features.

Finally, there is the shared code repository (I use code.google.com). Not only is this a tool that all professionals use, but it also helps me keep track of what is really going on, or not going on, in the project. Of course, it also helps the group coordinate their activities, as it was designed to.

So, yes, capstone projects should be an integral part of every Computer department's required curriculum, if the department is interested in creating graduates who can write software.

Still, I have to admit, it takes a lot of time to manage, advise, and code review 3 to 5 different projects at the same time. That might be the reason other universities either don't do this or leave their students on their own.

All Applications will be Web Applications

2009-08-14T14:02:00.002-04:00

I often mention this in my classes and other talks: it is clear that the majority of new applications will be web applications (not all of them, of course, that is just standard headline hyperbole).

Jeff Atwood gives some more reasons as to why this is happening. Basically, people like web applications because they don't have to install them or worry about what happens when they get a new computer, business like web applications because they don't have to worry about installing their custom software on every PC. We can see old desktop applications, Quicken, being replaced by web versions Mint which are better in many ways.

But the real draw of web applications lies in the interconnectedness they allow (see the photo above for an example). These applications are also services and provide REST API's for other applications to plug into them. In this way each application is also a programming library (remember DLL's and .so files?) and a database with up to date information. Thus, even the so-called desktop applications of the future will also be web applications in that they will suck down data from the web, like Google Earth. I am still trying to figure out what the proliferation of all these REST APIs and microformats will mean for multiagent systems, but I can't help but feel that this is good news for the field.

So, what does this mean for a new student? First of all, it is still programming. While you might be using a slightly higher-level language, you will still be writing for-loops, recursive functions, and lots of if-then statements. No one has invented a language that can eliminate those. Thus, nothing much changes. One still needs to have solid programming experience and knowledge of algorithms.

On the other hand, the architecture for web applications is different from the standard desktop. In a standard desktop application you write event handlers that run whenever the user clicks on a button. In web applications this becomes more complicated. You can write your JavaScript to handle events from the user, just like in a desktop application, but you also have to deal with the client-server communication (AJAX magic). This raises all sorts of very interesting questions about what activities should be handled in the server versus the client. For many of the current set of applications the decision seems easy (gmail) but it is not as clear for others: should mint.com generate their pie charts server-side or client-side? The decision depends on the user experience you are after as well as the capabilities of the client and server devices and the network that joins them (wired, wireless, reliable, spotty).

It is very exciting to realize that allowing others to use your software is as easy as emailing them the URL, and that they can use your software on their PC, netbook, smartphone, set-top box, kindle, etc. etc.

Best Way to Bid in a Distributed Combinatorial Auction?

2009-07-03T10:05:00.002-04:00

During the last year Benito Mendoza examined how different bidding strategies (really, algorithms) fare under the PAUSE auction. I would like to go over these results but first, some background.

A combinatorial auction is one where there are many items for sale at the same time and bidders can place bids on multiple items. For example, a bid might be "I'll pay $10 for items A,B, and X." These bids are then sent to the auctioneer which must find the set of winning bids that maximize revenue—– problem that is NP-complete. Check out this visualization of a combinatorial auction that I developed for class.

In the PAUSE auction there is no centralized auctioneer. The auction instead proceeds in steps. At the first step we hold parallel English auctions for each item. That is, everyone bids on every item individually. Thus, at the end we will have a (temporary) winning bid for each item. At the second set there is one auction but now all bidders must place bid-sets that cover all items in the auction, but they can use bids that the other agents placed before. Also, they can place bids that cover two items. For example, an agent might place a bid-set that includes a bid from itself for items A, and B, as well as bids, from other agents, for items C, D, and F. By restricting the agents to place complete bid-sets we are, in effect, forcing the bidding agents to solve the winner-determination problem using the existing public bids.

Well, sort of, because bidders are selfish they will want to place the bid that wins them the most items, for the least money (the bid-set that maximizes their utility). Two years ago we developed the PAUSEBID algorithm which a bidder can use to find the myopically-optimal bid-set: the bid-set that, if the auction were to end at that moment, maximizes the bidders's utility. The problem is that since this is an NP-complete problem PAUSEBID cannot be used in auction with more than about a dozen items. Thus, the next year we developed approximate bidding algorithms which have linear running time (way faster). This was good.

But, it raised another question: if the other bidders are using PAUSEBID, should I also use PAUSEBID, and spend all time computing, or should I use GREEDYPAUSEBID and save all that computational time at the risk of getting a lower utility? That is, should I think a lot about my next bid or just kinda wing it? The surprising results, which have to yet been published except on Benito's thesis, are that it is better for all bidders to use GREEDYPAUSEBID. That is, if all the other agents are using PAUSEBID, thus picking their bids optimally, then I can actually expect slightly higher utility by bidding with a simple greedy algorithm (GREEDYPAUSEBID). Also, in the world where all the agents are using GREEDYPAUSEBID the bidders get higher utility than in the world where they are all using PAUSEBID. What happens is that prices drop down a bit and thus all the bidders (buyers) win a bit, of course, the sellers lose.

Even more interesting, we also found that in the world where all the other bidders are using GREEDYPAUSEBID, my best strategy is to also use GREEDYPAUSEBID. Again, I would actually lose utility by trying to myopically-optimize my bidding strategy. Putting all these together we find that the population where all bidders use GREEDYPAUSEBID is stable (is a Nash equilbrium).

These results go against our initial intuitions. But, we must remember that an auction with lazy bidders will result in a lower sale price which benefits, on average, all bidders. Also, a myopically-optimal bidder will reveal utility gains to the other lazy bidders which they will then exploit, thus raising the final price.

Mendoza PhD in Bidding Algorithms

2009-06-16T10:26:00.004-04:00

Last month Benito Mendoza successfully defended his thesis. His research looks at the problems in establishing a distributed combinatorial auction, without the use of a central auctioneer, where the bidders have an incentive to participate and help find the best bidset.

I believe this work lays the foundation for future distributed resource allocation protocols. That is, currently companies and consumers engage in rather simple one-to-one sequential negotiations with each other: you negotiate with one car dealer, then another, then make a decision. These lead to sub-optimal allocations (translation: there was another solution where everyone in the world is happier than in the solution we ended up at). Now that all business is done on the Internet we can build sophisticated negotiation agents that will arrive at better global solutions by using the distributed resource allocation protocols that we are working on. But first, we must ensure that these protocols do find better solutions and are incentive-compatible and fair, and people want to use them (people are not always rational).

Read his thesis for more details:

Benito Mendoza Garcia. Economic and Computationally Efficient Algorithms for Bidding in a Distributed Combinatorial Auction.PhD Thesis. University of South Carolina, 2009.

Benito has accepted a position at Exxon doing agent-based modelling.

How to Email Rows from a Google Spreadsheet

2009-06-09T20:20:00.005-04:00

I have been keeping the grades from the various classes I teach in a google spreadsheet for almost two years now. It works great because I can share them with the TA or grader (back when we had TAs, before the budget cuts) while google docs maintains all the past revisions so I can always revert back if any one of us makes a mistake (always me, it turns out).

The only problem arises when I have to give the students their grades. Since the University has banned us from posting the grades outside our door, as my professors used to do, I have to email each row of the spreadsheet individually to each student. Luckily, google provides a spreadsheet API so I could write a short script that does just that.

The script below will email each row to the person whose email appears on the column named 'email', as shown in this sample spreadsheet. You will need python as well as the python gdata libraries installed for this to work. Installing them is just a matter of downloading and unzipping them in the same directory as the email-rows program below. Before you use it you will also need to change the sender and spreadSheetName to be your gmail username and the name of the spreadsheet you are using, respectively.

#!/usr/bin/python
# email-rows
#by
#jmvidal
#
#Emails every row from a google spreadsheet to the email address in that row.
#The spreadsheet must have a first row with a cell with 'email' in it.

import gdata.spreadsheet.text_db
import getpass
import atom
import smtplib
import time

def smtpLogin(password):
    """Login to the SMTP server. I'm assuming the smtp server is gmail"""
    global smtpServer
    smtpServer = smtplib.SMTP("smtp.gmail.com",587)
    smtpServer.ehlo()
    smtpServer.starttls()
    smtpServer.ehlo()
    smtpServer.login(sender, password)

def sendMessage(to,subject,body):
    headers = "From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n" % (sender, to, subject)
    message = headers + body
    print message + "\n===================================\n"
    if not testing:
        smtpServer.sendmail(sender, to, message)
    time.sleep(1) #so gmail won't ban me as a spammer

def emailRows(spreadSheetName, workSheetName):
    password = getpass.getpass()
    smtpLogin(password)
    client = gdata.spreadsheet.text_db.DatabaseClient(sender,password)
    db = client.GetDatabases(name=spreadSheetName)
    table = db[0].GetTables(name=workSheetName)[0]
    rows = table.GetRecords(1,1000)
    subject = spreadSheetName + ' grades'
    table.LookupFields() #populate table.fields

    for s in rows:
        if s.content['email']  and s.content['email'] != '':
            body = 'Your grades are:\n\n'
            for key in table.fields:
                if key == 'email' or key == 'name' or not s.content[key]:
                    continue
                body += key + '\t' + s.content[key] + '\n' 
            body += '\nJose\n'
            sendMessage(s.content['email'],subject,body)

testing = False #if testing is true then we don't send the emails, just print them.
sender = "username@gmail.com" #your gmail address

emailRows(spreadSheetName='Gdata 101', workSheetName='Sheet1')

If you like the idea but don't feel like running your own code then wait around here for a bit. I am working on turning this script into a web application so anyone can run it from the web.

Screencasting is Better than Lecturing

2009-05-12T08:31:00.000-04:00

Many years ago when I was an undergraduate, in the late 80's, I watched many of my lectures on the TV in our dorm room. Like many other schools at the time, MIT had its own cable channels that it delivered to the dorms. For several of the large classes there would be the standard lecture one could attend in person, but also a second lecture, by a second professor, that was designed solely for the camera. This TV lecture was filmed by a camera that was fixed to the ceiling pointing down to a pad of paper on which the prof. wrote. All we could see was his hand writing on the piece of paper, with occasional cuts to a head shot of him. The TV lectures then played on a continuous loop, 24/7, on the various cable channels. They were very popular with students. I even vaguely remember some drinking games constructed around them. They were the original version of the MIT Open Courseware.

Flash forward to the present and now we all can afford the technology to do even better. Thus, this last semester I decided to use online screencasts instead of real world lectures in my 242 (web applications) class, you can see the screencasts here. I followed a now somewhat established model of having the students see the lectures at home and then class consisted of hands-on exercises. I was then able to provide each student with one-on-one help in doing the exercises (these exercises were not quizes and I provided as much help as needed to get it done). This model works very well. Of course, it probably only works with small classes. I had 9 students in the class.

The feedback I received from the students was positive. Some of the main lessons I learned are

Students that already know most of the material did not watch the videos, instead they read the slides and other material I provided. These are probably the same students who would show up to class and spend all their time facebooking or somesuch. So, I think I saved them some time.
The rest of the students do watch the videos and find them useful. Students new to the material will go back and re-watch parts. They all really love the fact that they can watch at any time.
Having in-class exercises is critical as they tell me exactly how much each student knows and they drive home the message that you cannot learn how to program by watching a lecture: you have to practice. Without these exercises it is likely some students would have waited until the last day before a homework is due to practice, at which point it is impossible to get the homework done so they would have copied it. This would just increase the number of students who cannot program.
On the technical side, I used Camtasia ($299, free trial) to record the lectures and posted them to vimeo. I learned that (a) I have to eliminate the background buzzzz noise one always gets when recording as it gets really annoying (Camtasia lets me do this by pressing a button) (b) programming screencasts have to be in HD (1280x720) as regular resolution makes it really hard to see the text, only vimeo let me host HD videos at a reasonable price ($60/year).
I also bought the Bamboo Pen Tablet so I could freestyle draw on the slides. This worked fairly well, but my handwriting is even worse on the videos than in real life because I have not gotten used to writing on the pad while looking at the screen. Still, I think it helped for explaining some ideas.

Screencasting is better than lectures in that it allows students to proceed at their own pace. This is a significant advantage in CSE where we have such a large variance in the skillset of students. Still, it should be paired with even more one-on-one student contact. In effect, the teacher (or TAs, if you have them) becomes a tutor for every student in class.