At RedSnake Philly one of the presenters talked about what he had done with Google Apps Scripts. I decided to take a look at it to see if I could automate emailing grades from a spreadsheet. It turns out that not only is it possible, but it’s pretty easy to do. The script to send an email to each student on our list is only about 10 lines long.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

function sendEmails() {
  var sheet = SpreadsheetApp.getActiveSheet();
  var startRow = 2;
  var numRows = 19;
  var numColumns = 25;
  var dataRange = sheet.getRange(2, 1, numRows, numColumns);
  // Fetch values for each row in the Range.
  var data = dataRange.getValues();

  var headerRange = sheet.getRange(1, 1, 1, numColumns); //The first row tells us what each value means.
  var header = headerRange.getValues()[0]; //Treat it as a single dementional array
  for (i in data) {
    var row = data[i]; //Row of current users data
    var emailAddress = row[0] + "@seas.upenn.edu";  // add domain to pennkey
    var message = generateHtmlEmail(header, row);
    var subject = ScriptProperties.getProperty("EmailSubject");; //This should be changed for each assignment.
    MailApp.sendEmail(emailAddress, subject, message,
                      {htmlBody: message,
                       cc: "teacherAndOtherTAs" });
  }
}

The generate email function is a little more exciting. It uses a google doc as a template, and fills in the grade by replacing the header template in the doc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function getHtmlEmail(header, row) {
  var templateDocId = ScriptProperties.getProperty("TemplateID"); //Look up template id.
  var docId = DocsList.getFileById(templateDocId).makeCopy().getId();
  var doc = DocumentApp.openById(docId);
  var body = doc.getActiveSection();
  var html = "";

  for ( var h in header ){
    body.replaceText("%" + header[h] + "%", row[h]); //Replace template code with the current students grades.
  }

  doc.saveAndClose();
  html = getDocAsHtml(docId);
  DocsList.getFileById(docId).setTrashed(true); //throw the doc away since we no longer need it.
  return html;
}

First we copy the document. We can then replace each variable that corresponds to a row header and return the html to send as an email.

This easily sends emails to everyone in the class. However, I still have a bit of work. Regrades require individual messages. I want to add some sort of flag that only resends messages to users when their grades changes.

The webapp is written in Rails and is integrated in many components of our workflow.

The workflow:

• Jordan generates images using the python Image class. These images are generated uniformly at random across the RGB color space (Defines a color by the amount of red, green and blue).

• I take the image and upload them to our web app. Our database stores the images, as well as the corresponding foreground and background colors.

• I then divide them into groups of 8 images and create an experiment. An experiment contains 8 images and three signpost images. I will attempt to discuss the sign posts in more detail in a future post, but they are used to help calibrate our results across experiments.

• Using the gem Turkee, I can launch these experiments in groups to Mechanical Turk. We pay users get 3-5 cents for each survey they complete.

• As results come in, we download these results, and generate a CSV file of all comparisons. Ayaka feeds these comparisons into a MATLAB implementation of an model called MLSD. This converts our binary comparisons to a linear scale where each image is given a single value representing its location on a line. I will try to go into more detail on this in a future post.

• We can then feed these values back into the database, giving us a single value for each image. From here we generate an Attribute-Relation File (ARFF) that we can feed into Weka. Our goal here is to generate a model that can accurately predict the readability value we previously assigned.

It has taken a while to get all our pipeline components working the way we want, but now that everything is well tested we should begin launching a large number of experiments in the near future and have results soon after that.

For me these issues take up such a small chunk of my day that they aren’t worth taking the time to fix, especially because there’s a good chance I’ll just want to change it again in the future.

I believe, as a programmer, I have naturally developed an extremely high error tolerance. More than once I have come across a bug for the first time that requires an hour or so research to learn the trivially stupid mistake I made. If I had not been able to develop such a high error tolerance I would have quit computer science years ago.

While in many cases this kind of patience is a great trait, it is important to be aware of the times where it can be detrimental.

I am currently working on designing my first major web application. I just presented it to my boss last week, and he pointed out my biggest mistake. I was applying my error tolerance in the app flow. For example, when a user invited people to join a project, it would redirect the user back to the home screen instead of the project page they came from. Another example is that users can be selected for certain tasks. However I was also displaying users who had not yet filled out their name. Thus many of these choices were blank.

I overlooked these errors that I would probably realize are big mistakes if I spent an extra second thinking about them. Instead I naturally ignore them, since I put up with worse errors everyday.

While error tolerance is sometimes a great trait, with UX design, it is important to forget this skill and not put up with any mistakes.

Here is the files model I created to treat files stored on aws the same as things stored in the database.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

class ProjectFile
  attr_accessor :children, :size, :path

  EXT_MAP =  {
      'xls'  => :xls,
      'xlsx' => :xls,
      'doc'  => :doc,
      'docx' => :doc,
      'zip'  => :zip,
      'txt'  => :txt,
      'pdf'  => :pdf,
      'sql'  => :sql,
  }

  def self.find_by_project_name(name)
    project_files = self.files.all({:prefix => name})
    output_files = Hash.new
    file_lookup = Hash.new
    root = nil

    project_files.each do |project_file|
      file_lookup[project_file.key] = convert(project_file)
    end

     file_lookup.values.each do |project_file|
      if project_file.parent_name.nil?
        root = project_file
      else
        parent = file_lookup[project_file.parent_name]
        parent.children ||= []
        parent.children  << project_file
      end
     end
    return root
  end

  def self.find_link_by_name(name)
    fog_file = self.files.get(name)
    expiration = Time.now + 60.seconds
    fog_file.url(expiration)
  end

  def self.convert(fog_file)
    file = ProjectFile.new
    file.size = fog_file.content_length
    file.path = fog_file.key
    file.children = nil
    return file
  end

  def self.files
    FOG_STORAGE.directories.get(Settings.aws_bucket).files
  end

  def extension
    ext = self.path[path.rindex(/\./) + 1..-1]
    EXT_MAP[ext]
  end

  def extension_css
    unless extension.nil?
      extension.to_s
    else
      "default"
    end
  end

  def file_name
    parent_index = path.rindex(/\//,-2)
    if parent_index.nil?
      path
    else
      path[parent_index +1..-1]
    end
  end

  def parent_name
    parent_index = path.rindex(/\//,-2)
    if parent_index.nil?
      nil
    else
      path[0..parent_index]
    end
  end

  def is_directory?
    not children.nil?
  end

  def str_size
      if size > 1024 * 1024 * 1024
        "%0.0f GB" % (size / (1024 * 1024 * 1024))
      elsif size > 1024 * 1024
        "%0.0f MB" % (size / (1024 * 1024 ))
      else
        "%0.0f KB" % (size / 1024)
      end
  end
end

Files are displayed to uses using a tutorial on collapse tree for file structures. A simple helper function converts the data structure to the proper nested list explained in this example.

A few examples of great gems are: devise cancan, and rolify - Together these gems provide a very powerful and robust way of managing users and permissions. The app has three permission levels researchers, researcher assistants, and admins. Each of these groups will have certain rights and retrictions which are easily managed through these gems.

fog - used to interact with amazon web services through ruby code. Fog can manage amazon instances and files though simple ruby functions.

twitter-bootstrap-rails and simple-form-for - automatically makes forms with bootstrap components, greatly improving design with minimal additional coding.

Personal Goals

Setting personal goals outside the simple scope of the project is important to me. I am still learning, and a good way to keep learning is to focus on things that I need to improve while working on a project.

I have a few goals for this project, but most importantly I want to focus on testing. Testing is extremely useful, both for making sure code does what is expected, and ensuring that code wont be broken in the future.

Unfortunately I often overlook testing though. It is often hard to see the time that it saves since it doesn’t directly convert to progress on the site. However, it saves a lot of time by catching errors before they are published. It also is often easier to design a function when you can test in as you build.

Background

WCAI (The Wharton Customer Analytics Initiative) is “The world’s preeminent academic research center focusing on the development and application of customer analytics methods.” Every few months WCAI receives a dataset from a corporate partner (ranging from ticket sales on StubHub to email marking data from Charming Shoppes). After receiving the data, WCAI does some queries and a basic analysis of the data before sending the data to top researchers across the country. Throughout the research process WCAI supports the researchers by providing access to the data as well as performing any additional queries they may need.

Currently there is no standardized way to store the data for the life of the project. The raw files are submitted and stored on box.com, but for analysis they must be loaded into a database. Some projects are loaded into a MySQL or Postgres database on Wimi-Cruncher (the in-house server), others are stored locally on researchers’ computers in a database program like Microsoft Access. Our goal is to create a uniform long-term storage solution for new projects.

Proposal

The wimi-crucher server is outdated, so in the process of looking at ways to replaces the server I was asked to estimate the cost of running future projects on Amazon Web Services. Here’s a quick table of the per project estimated costs on Amazon.

AWS also offers great additional features such as image backup, the ability to change instance sizes as needed, and Glacier, a cheap long-term data storage solution.

Notice that we can also only pay for the server hours we need. Since server usage is charged by the hour, we only have to pay for the hours we have an instance up to perform queries.

Compared to the cost of purchasing a server or buying a virtual machine though Penn, this was by far the cheapest and most flexible choice, so we made the decision to set it up for the next project.

Implementation

While AWS has done a fantastic job at providing many simple and intuitive ways to control instances, we want to be able to provide a straightforward method for a researcher to spin up a project instance and perform queries without having to understand too much of the underlying infrastructure. I have been assigned the task of creating an app to perform this functionality, and will describe the implementation choices I made in future posts.