My approach in an idea world would be to have all of my data (or links to it) under version control along with the code. When the version to be used for the publication is clear I would give it a tag (I’m a Git user but there is similarly functionality in all version control systems) and then push that to an online repository. You can then give a link or reference to the appropriate repository version online. If you don’t want to put your main repository online then you could just put up the version from the publication.

Of course this is not so easy if you are doing it in retrospect. Your data may be in other places in systems that aren’t under proper version control. If the data is small enough I would grab a copy and put it in the repository version you are using for publication. If its big and stored remotely then you are a bit limited. In that case I would try and refer to a specific version if it is possible, or if you can’t do that then you can try and get a checksum.

But basically the main thing is to create and refer to a specific version of your repository and make sure it is available in a useful form to people who want to check it out.

For this tutorial, we’ll be plotting some weather data from a site call Weather Underground. You can download temperature readings and weather events for your local area in a comma-separated file.

I’ve put weather data for Bloomington, IN in a file called weather.csv. Each row is one day, and there are columns for min/mean/max temperature, dew point, wind speed, etc. We’ll be plotting temperature and weather event data (e.g., rain, snow).

0. Installing matplotlib

I covered installing matplotlib in a previous tutorial. The matplotlib site also has installation instructions. I’ll assume for the rest of the tutorial that you have matplotlib installed and working. If you can type this code at a Python shell:

from matplotlib import pyplot

and not receive any errors, then you’re good to go.

1. Numpy Crash Course

The numpy module is how you do matrix-y stuff in Python. I’ll give a quick example of why we’ll need it. Imagine you were to type the following code into a Python shell:

x = [1, 2, 3, 4]
print x * 5

What does this print? Why, this of course:

[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

By default, the * operator in Python copies the contents of a list however many times you specify. So x * 5 copied the contents of x five times and stuck them all together.

When we’re doing matrix math in Python, it would be nicer if x * 5 produced [5, 10, 15, 20]. We could do this manually with a loop:

for i in range(len(x)):
    x[i] = x[i] * 5

We could even get fancy with Python’s list comprehension syntax:

x = [x_i * 5 for x_i in x]

For a list with only four elements, this won’t be so bad. For larger lists, however, it will be quite slow. Using numpy avoids the performance hit by doing the heavy lifting in C instead of in Python. Here’s how we’d do the previous example with numpy:

import numpy as np
x = np.array([1, 2, 3, 4])
x = x * 5
print x

This prints array([ 5, 10, 15, 20]) which is what we would expect. The array(...) lets you know that x is a numpy array. Onward!

2. Reading the Data

As with many programming problems, our first step is to read the data into memory. I’ve started a script called plot_data.py with a few import statements and some utility functions. I’ll explain these functions in detail as we go forward.

import numpy as np
import matplotlib.pyplot as pyplot
from datetime import datetime
import os

event_types = ['Rain', 'Thunderstorm', 'Snow', 'Fog']
num_events = len(event_types)

def event2int(event):
    return event_types.index(event)

def date2int(date_str):
    date = datetime.strptime(date_str, '%Y-%m-%d')
    return date.toordinal()

def r_squared(actual, ideal):
    actual_mean = np.mean(actual)
    ideal_dev = np.sum([(val - actual_mean)**2 for val in ideal])
    actual_dev = np.sum([(val - actual_mean)**2 for val in actual])

    return ideal_dev / actual_dev

In past tutorials, we’ve either manually parsed our data file(s) or used Python’s csv reader. Because of our focus on numpy here, we’re going to use the loadtxt function. By passing in the right options, we can get loadtxt to parse our weather.csv file directly into a numpy array.

For a first pass, I’ve written the following function to read in the weather data:

def read_weather(file_name):

    data = np.loadtxt(file_name, delimiter=',', skiprows=1,
            converters = { 0 : date2int },
            usecols=(0,1,2,3,21))

    return data

#-------------------------------------------------- 

data = read_weather('data/weather.csv')
print data

The first two parameters, delmiter and skiprows tell loadtxt to split fields based on commas and skip the first row of the file (which contains column names). numpy doesn’t handle dates, so I’ve used the converters parameter to have have loadtxt convert column 0 (a date string) into an integer using my date2int function. The last parameter, usecols, tells loadtxt to ignore all columns in the file except the first, second, third, forth, and twenty-second column (the date, temperature, and weather event columns).

Unfortunately, running this code produces the following error:

$ python plot_data.py
Traceback (most recent call last):
  File "plot_data-2.py", line 34, in <module>
    data = read_weather("data/weather.csv")
  File "plot_data-2.py", line 28, in read_weather
    usecols=(0,1,2,3,21))
  File "/usr/lib/python2.7/dist-packages/numpy/lib/npyio.py", line 796, in loadtxt
    items = [conv(val) for (conv, val) in zip(converters, vals)]
ValueError: could not convert string to float: Rain

The final line tells us that numpy can’t convert the string “Rain” into a floating point number. This is from the weather events column in our data, which contains text like “Rain” or “Snow-Fog”. We could try and write a converter for this column too, but I’ve chosen to simply have numpy bring the column in as a string (which we’ll manually parse later).

To do this, we pass in a special object for the dtype parameter of loadtxt. This object can be constructed by giving a dictionary to the numpy.dtype function. The code below provides names and data types for all of the columns we’ll be using:

def read_weather(file_name):
    dtypes = np.dtype({ 'names' : ('timestamp', 'max temp', 'mean temp', 'min temp', 'events'),
                        'formats' : [np.int, np.float, np.float, np.float, 'S100'] })

    data = np.loadtxt(file_name, delimiter=',', skiprows=1,
            converters = { 0 : date2int },
            usecols=(0,1,2,3,21), dtype=dtypes)

    return data

The last column format is given as “S100″, which means “string up to 100 characters in length.” numpy needs to know the maximum size of the column for efficiency, so I gave myself plenty of room with 100 characters. Running this new code produces the following output:

$ python plot_data.py
[(734503, 53.0, 43.0, 32.0, 'Rain') (734504, 32.0, 25.0, 18.0, 'Snow')
 (734505, 27.0, 20.0, 12.0, '') (734506, 42.0, 34.0, 26.0, '')
 (734509, 52.0, 40.0, 28.0, '') (734510, 47.0, 36.0, 24.0, '')
 (734511, 51.0, 38.0, 24.0, '') (734512, 57.0, 43.0, 28.0, '')
 (734513, 45.0, 43.0, 40.0, 'Rain') (734514, 43.0, 29.0, 15.0, 'Fog-Snow')
 (734515, 19.0, 17.0, 15.0, 'Snow') (734516, 27.0, 18.0, 9.0, 'Snow')
 ...

We're finally in business. Each row in our data set consists of a timestamp (the date converted to an integer), the maximum, mean, and minimum temperature, and the weather events that occurred that day. We're going to start by plotting the mean temperature versus the day of the year. Since we've given names to each of our columns, we can pull them out easily:

def read_weather(file_name):
    dtypes = np.dtype({ 'names' : ('timestamp', 'max temp', 'mean temp', 'min temp', 'events'),
                        'formats' : [np.int, np.float, np.float, np.float, 'S100'] })

    data = np.loadtxt(file_name, delimiter=',', skiprows=1,
            converters = { 0 : date2int },
            usecols=(0,1,2,3,21), dtype=dtypes)

    return data

#-------------------------------------------------- 

data = read_weather('data/weather.csv')
min_temps = data['min temp']
mean_temps = data['mean temp']
max_temps = data['max temp']
dates = [datetime.fromordinal(d) for d in data['timestamp']]
events = data['events']

for date, temp in zip(dates, mean_temps):
    print '{0:%b %d}: {1}'.format(date, temp)

Each column can be extract individually from the data array by using data['column name']. I’ve used the datetime.fromordinal function on the timestamp column to convert the integers back into datetime objects.

Using the handy built-in zip function, I’ve printed out pairs of dates and mean temperatures. I use advanced string formatting to print the month, day, and temperature (see the datetime documentation for date formatting information). The program now gives the following output:

Jan 01: 43.0
Jan 02: 25.0
Jan 03: 20.0
Jan 04: 34.0
...
May 11: 59.0
May 12: 62.0
May 14: 69.0

Everything looks good, so let’s get started plotting.

3. Temperature Plot

We’re going to start with a simple line plot that has the day of the year on the x-axis and the mean temperature for that day on the y-axis. Our plotting function, called temp_plot, will take in dates and times, and give us back a matplotlib figure object. Here’s the code:

def temp_plot(dates, mean_temps):

    year_start = datetime(2012, 1, 1)
    days = [(d - year_start).days + 1 for d in dates]

    fig = pyplot.figure()
    pyplot.title('Temperatures in Bloomington 2012')
    pyplot.ylabel('Mean Temperature (F)')
    pyplot.xlabel('Day of Year')

    pyplot.plot(days, mean_temps, marker='o')

    return fig

We start by computing the day of the year for each date. The datetime module lets us subtract dates from each other, producing a timedelta object. We subtract each date from January 1st of 2012, adding 1 so that our count will start from 1 instead of 0. The days field on a timedelta object gives the total number of days (in this case, from January 1st).

Next, we create a new matplotlib figure. In between calls to pyplot.figure, matplotlib's plotting functions will draw new plots on top of old ones. We’ll use this fact to add a trend line to our plot shortly.

After adding a title and some axis labels to our figure, we call pyplot.plot with our days (x values) and mean_temps arrays (y values). I’ve also passed in ‘o’ to the optional marker parameter so that small circles will be plotted for each data point.

In the main body of the program, we use the os module to create a “plots” directory (checking if it exists first). Next, we call our temp_plot function and then use savefig to save the figure out to a png file:

data = read_weather('data/weather.csv')
min_temps = data['min temp']
mean_temps = data['mean temp']
max_temps = data['max temp']
dates = [datetime.fromordinal(d) for d in data['timestamp']]
events = data['events']

if not os.path.exists('plots'):
    os.mkdir('plots')

fig = temp_plot(dates, mean_temps)
fig.savefig('plots/day_vs_temp.png')

Running $ python plot_data.py should create a “plots” folder and put a file inside called “day_vs_temp.png” that looks like this:

Not bad! Let’s add a trend line to the plot based on a simple linear model of the data.

3.1 Adding a trend line

By using numpy’s polyfit function, adding a trend line is a snap. This function takes our x and y values (days and mean_temps), and gives us back a slope and intercept (the final parameter is the degree of the fitted polynomial — we pass 1 for a linear fit).

slope, intercept = np.polyfit(days, mean_temps, 1)

Using the slope and intercept, we can plot a trend line by computing “ideal” temperatures for each day according to the old y = mx + b formula. With our variables below, this will be ideal_temps = (slope * days) + intercept. Note that I’ve changed the days = ... line to days = np.array(...) so that we can do mathematical operations directly on the array.

def temp_plot(dates, mean_temps):

    year_start = datetime(2012, 1, 1)
    days = np.array([(d - year_start).days + 1 for d in dates])

    fig = pyplot.figure()
    pyplot.title('Temperatures in Bloomington 2012')
    pyplot.ylabel('Mean Temperature (F)')
    pyplot.xlabel('Day of Year')

    pyplot.plot(days, mean_temps, marker='o')

    slope, intercept = np.polyfit(days, mean_temps, 1)
    ideal_temps = intercept + (slope * days)
    r_sq = r_squared(mean_temps, ideal_temps)

    fit_label = 'Linear fit ({0:.2f})'.format(slope)
    pyplot.plot(days, ideal_temps, color='red', linestyle='--', label=fit_label)
    pyplot.annotate('r^2 = {0:.2f}'.format(r_sq), (0.05, 0.9), xycoords='axes fraction')
    pyplot.legend(loc='lower right')

    return fig

To make the plot a little more useful, I’ve annotated the plot with the R-squared value of the fit. pyplot.annotate lets you put text on the figure in a variety of ways. Here, I’ve set the xycoords parameter to “axes fraction” so that annotate interprets my coordinates (0.05, 0.9) as fractions between 0 and 1 relative to the figure axes. The (0.05, 0.9) means to place the text horizontally 5% from the y-axis (left) and 90% from the x-axis (bottom).

The final call to pyplot.legend places a legend on the figure. You must include a label parameter on at least one plot object for this to work (I’ve included it on the trend line plot call). By default, the legend will show up in the upper-right corner of the figure. This will get in the way on our current plot, so I moved the figure to the lower-right with the loc parameter.

With the changes above, here’s the new plot:

Notice that the string formatting ({0:.3f}) has rounded the R-squared value and slope label for us to three decimal places.

3.2 Adding “error” bars

Since we also have the min and max temperatures in our data, let’s add “error” bars to our plot to show the temperature range on each day. We’ll modify temp_plot to take in two additional parameters (min_temps and max_temps), and plot the temperature range if they both have values (i.e., are not None).

Adding error bars requires us to use the pyplot.errorbar function instead of pyplot.plot. It takes additional parameters (xerr and yerr) for the x and y errors. We will use yerr, and pass in an array with two rows: one for error above each data point, and one for the error below. This array is easily computed by subtracting the max and min temperatures from the mean, and then stacking the two arrays together row-wise with numpy.vstack.

def temp_plot(dates, mean_temps, min_temps = None, max_temps = None):

    year_start = datetime(2012, 1, 1)
    days = np.array([(d - year_start).days + 1 for d in dates])

    fig = pyplot.figure()
    pyplot.title('Temperatures in Bloomington 2012')
    pyplot.ylabel('Mean Temperature (F)')
    pyplot.xlabel('Day of Year')

    if (max_temps is None or min_temps is None):
        # Normal plot without error bars
        pyplot.plot(days, mean_temps, marker='o')
    else:
        # Compute min/max temperature difference from the mean
        temp_err = np.row_stack((mean_temps - min_temps,
                                 max_temps - mean_temps))

        # Make line plot with error bars to show temperature range
        pyplot.errorbar(days, mean_temps, marker='o', yerr=temp_err)
        pyplot.title('Temperatures in Bloomington 2012 (max/min)')

    slope, intercept = np.polyfit(days, mean_temps, 1)
    ideal_temps = intercept + (slope * days)
    r_sq = r_squared(mean_temps, ideal_temps)

    fit_label = 'Linear fit ({0:.2f})'.format(slope)
    pyplot.plot(days, ideal_temps, color='red', linestyle='--', label=fit_label)
    pyplot.annotate('r^2 = {0:2f}'.format(r_sq), (0.05, 0.9), xycoords='axes fraction')
    pyplot.legend(loc='lower right')

    return fig

#-------------------------------------------------- 

data = read_weather('data/weather.csv')
min_temps = data['min temp']
mean_temps = data['mean temp']
max_temps = data['max temp']
dates = [datetime.fromordinal(d) for d in data['timestamp']]
events = data['events']

if not os.path.exists('plots'):
    os.mkdir('plots')

# Plot without error bars
fig = temp_plot(dates, mean_temps)
fig.savefig('plots/day_vs_temp.png')

# Plot with error bars
fig = temp_plot(dates, mean_temps, min_temps, max_temps)
fig.savefig('plots/day_vs_temp-all.png')

The new plot is saved to a file named day_vs_temp-all.png and looks like this:

If you need to compute standard error for your errorbar plot, you can use scipy.stats.sem from the scipy module.

For our next plot, we’ll do a multi-part histogram of the weather events for each month.

4. Event Histogram

Histograms in matplotlib are generated using the pyplot.hist function. This function takes an array of data, which can itself contain arrays (for a multi-part histogram). We want to count events per month, so we’ll need to create an array for each type of event. Inside these arrays will be observations like [1, 1, 2, 3, 3] for “January”, “January”, “February”, “March”, “March”. Here’s a diagram to help out:

When pyplot.hist receives our data, it will attempt to “bin” the month observations automatically. By default, it will break observations into 10 bins. We want a bin for each month instead, and we want the bins aligned properly to the month numbers (1 = January, 2 = February, etc.). The bins parameter to pyplot.hist takes either a number (representing the desired number of bins) or a sequence (representing the desired bin edges). In the code below, we pass range(1, 5 + 2) to ensure that our bins start at 1 (for January) and go through 5 (for May).

def hist_events(dates, events):
    event_months = []

    for i in range(num_events):
        event_months.append([])

    # Build up lists of months where events occurred
    for date, event_str in zip(dates, events):
        if len(event_str) == 0:
            # Skip blank events
            continue

        month = date.month

        # Multiple events in a day are separated by '-'
        for event in event_str.split('-'):
            event_code = event2int(event)
            event_months[event_code].append(month)

    # Plot histogram
    fig = pyplot.figure()
    pyplot.title('Weather Events in Bloomington 2012')
    pyplot.xlabel('Month')
    pyplot.ylabel('Event Count')

    bins = np.arange(1, 5 + 2)
    pyplot.hist(event_months, bins=bins, label=event_types)

    pyplot.legend()

    return fig

The main body of the program is updated to call hist_events and save the resulting figure to plots/event_histogram.png.

data = read_weather('data/weather.csv')
min_temps = data['min temp']
mean_temps = data['mean temp']
max_temps = data['max temp']
dates = [datetime.fromordinal(d) for d in data['timestamp']]
events = data['events']

if not os.path.exists('plots'):
    os.mkdir('plots')

fig = temp_plot(dates, mean_temps)
fig.savefig('plots/day_vs_temp.png')

fig = temp_plot(dates, mean_temps, min_temps, max_temps)
fig.savefig('plots/day_vs_temp-all.png')

fig = hist_events(dates, events)
fig.savefig(os.path.join('plots', 'event_histogram.png'))

When we run $ python plot_data.py, the new plot looks like this:

Each collection of bars represents a month, and the individual bars represent the number of Rain, Thunderstorm, etc. events observed for that month. The figure’s legend was populated by passing event_types in for the label parameter of pyplot.hist.

The plot looks good, but it would be nice to properly label the months. We could do this manually with pyplot.xticks as follows:

pyplot.xticks( (1.5, 2.5, 3.5, 4.5, 5.5), ('January', 'February', 'March', 'April', 'May') )

This will label each bin in the center (hence the .5 added to each number) with the proper month name. If our data grows to include more months, however, we’ll have to manually extend the number of bins and our labels. Let’s change hist_events to keep track of the range of months in the data. Additionally, we’ll use Python’s calendar module to automatically get the month names.

At the top of the program, we’ll import the calendar module:

import calendar

and then redefine hist_events as follows:

def hist_events(dates, events):
    event_months = []

    for i in range(num_events):
        event_months.append([])

    # Build up lists of months where events occurred
    min_month = 13
    max_month = 0

    for date, event_str in zip(dates, events):
        if len(event_str) == 0:
            # Skip blank events
            continue

        month = date.month
        min_month = min(month, min_month)
        max_month = max(month, max_month)

        # Multiple events in a day are separated by '-'
        for event in event_str.split('-'):
            event_code = event2int(event)
            event_months[event_code].append(month)

    # Plot histogram
    fig = pyplot.figure()
    pyplot.title('Weather Events in Bloomington 2012')
    pyplot.xlabel('Month')
    pyplot.ylabel('Event Count')
    pyplot.axes().yaxis.grid()

    num_months = max_month - min_month + 1;
    bins = np.arange(1, num_months + 2)  # Bin edges
    pyplot.hist(event_months, bins=bins, label=event_types)

    # Align month labels to bin centers
    month_names = calendar.month_name[min_month:max_month+1]
    pyplot.xticks(bins + 0.5, month_names)

    pyplot.legend()

    return fig

During the process of building our observation arrays, we now track the minimum and maximum months observed. This allows us to automatically create our bin edges, and let’s us grab months names from the calendar module by indexing into the calendar.month_name list.

Note that the bins variables was created using numpy.arange, which is a shortcut for bins = numpy.array(range(1, num_months + 2)). Making bins a numpy array lets us call pyplot.xticks with bins + 0.5, centering month_names on each bin.

As a bonus, I’ve also added a horizontal grid using the axis.grid function. You can add both a horizontal and vertical grid at the same time by calling pyplot.grid.

Here’s the updated plot:

Looks ready for publication!

[Code and Data]

Who are we?

• A learner learns new tools and skills.
• A tutor passes on their knowledge.
• A workshop host organizes and runs a boot camp.
• An author creates content (lessons, blog posts, exercises, etc.).
• An admin manages the web site.
• Innocent bystanders watch and comment from the sidelines

An individual might assume any of these roles at different times or in different contexts. For example, workshop hosts are often tutors, a tutor for one topic may be a learner for another, authors are often admins and vice versa, etc.

What do we do?

• A workshop is a live event, typically running all day for two days. A workshop is made up of several lessons, which may use the content we have online (or at least improvise around it), but which usually remix the order.
• A course is a slower-paced event, typically running for a few hours once a week for several weeks. Courses use our online material (or don’t) just like workshops.
• A tutorial is an ad hoc real-time session with one tutor and several learners. Tutorials can be online or live.
• A help session is an ad hoc session between one tutor and one learner. Help sessions can be online or live.
• A content jam is a live get-together to create or update content. We haven’t actually had one of these yet, but I’m hopeful…

What do we use to interact?

• Skype and desktop sharing for real-time online events. We’ve been using BlueJeans for one-to-many tutorials; it works pretty well, but doesn’t seem to allow people to use Skype text chat while in a session, and we’ve never been able to make recording work. It’s also very expensive, but cheaper alternatives (WebEx, Google+ hangouts) haven’t scaled as well.
• Our WordPress blog. We manually echo posts to Twitter.
• Twitter (tweets aren’t currently archived on our site, but should be).
• Web pages in our WordPress site. This includes the online course material, ads for workshops, and a few bits of advertising.
• Comments on the WordPress material. (People have suggested adding forums as well, but I don’t believe there would be enough traffic, and we all have too many places to pay attention to already.)
• Videos (hosted at YouTube, embedded in the WordPress site).
• Point-to-point email. (This is usually from and to people’s personal accounts, so it isn’t archived.)
• Our own mailing lists: one for workshop organizers and content developers, and others for various regions and workshops. These are archived, but since we use MailMan, they’re not integrated with WordPress. (I’ve experimented with various mailing list plugins for WordPress, and haven’t been impressed by any of them.) We manage these lists through the Dreamhost control panel.
• Subversion. We have a publicly-readable repository for the course material and a members-only repository for administrative stuff like grant proposals. We also set up one repository for each workshop group, which we keep live for a couple of months. We also manage repos through the Dreamhost control panel, but there’s no way to automatically keep their membership and permissions in sync with the group mailing lists.
• EventBrite for event registration. We link to EventBrite sign-up pages for events from the corresponding WordPress pages, but the linkage is done manually. EventBrite also gives us a mailing list for each event; we should use these to contact workshop participants immediately before and after workshops rather than our MailMan lists.
• Google Calendar and Google Maps to show when and where upcoming workshops are. Our calendar and map are linked into a page on the WordPress site, but updates have to be done manually. In particular, we have to remember to add events to both the calendar and the map, and when an event is over, we have to change the map as well as moving the event’s page to the “past” section of the site.
• Doodle to schedule tutorials.

One thing we don’t have yet is badges. We’d like to issue these to people who have taken part in workshops and the follow-up tutorials (i.e., our “graduates”), and also to instructors and content creators. The Open Badges team is working on a WordPress plugin to do this, which we hope to deploy in June.

How do we interact?

• Synchronously, i.e., taking part in or delivering workshops, courses, tutorials, help sessions, and content jams, both live and online.
• Scheduling events using Doodle.
• Registering for (and unregistering from) events using EventBrite.
• Advertising events using MailMan lists, the blog, and Twitter.
• Updating people on changes to workshops and courses using MailMan lists and EventBrite lists.
• Writing blog posts.
• Writing pages.
• Commenting on blog posts and pages.
• Tweeting.
• Creating or updating content in the main Subversion repository (and then updating the web site if needed).
• Creating and uploading videos, and then linking to them in a blog post or from a page.
• Discussing things on the “dev” list. There’s almost never discussion on the per-workshop lists: I feel like there should be (or should be forums or something), but help sites need critical mass, and I doubt we’ll ever have it, so I’d rather put energy into teaching people how to use existing online Q&A sites well.
• Giving feedback about events. Right now, we collect good and bad points from people at the end of every workshop, then post them to the blog. We really need to collect feedback on tutorials, and to follow up with people months or years later.

What’s wrong with all this?

• Speed and design: the existing web site is slooooow, and no one would call the existing site beautiful…
• Identity: scheduling is separate from registration is separate from the mailing lists and from repositories. Badging will only make that more complicated. Mozilla Persona (formerly BrowserID, and not the same thing as OpenID—are you confused yet?) isn’t a complete solution: it handles authentication, but not authorization, and “who can do what?” is an authorization issue. OAuth is supposed to take care of the latter, but it it’s a looong way from meeting our needs.
• Integration: connecting our blog to Twitter would be easy—I just haven’t bothered to set it up. But tweets should be archived on the web site (both the ones we make and mentions of us), the mailing list archives should be integrated into the site, and so on. Again, there’s a lot more to this than just managing identities.
• Features: I’d like a live table of registration stats (how many people have signed up for all upcoming events, and how many tickets remain) on the web site, but EventBrite doesn’t have embeddable HTML for that. I’d also like a person-by-list table showing who’s on which mailing list, and who has access to which repository, but Dreamhost and MailMan don’t offer that. And I’d like the colors of map pins to change automatically once a workshop is over, but—you get the picture. All of these things can be fixed with the right glue code, but I have bigger yaks to shave.
• Conversation: the most important missing element is regular back-and-forth with the people we’re trying to help. Again, I think that our goal should be to get them onto existing Q&A sites like Stack Overflow; in particular, we should help them feel confident enough to hang out there, so they don’t become part of the dark matter of computational science.

What do I want?

I’ve written before about the idea of a GitHub for education, but that wouldn’t address all of the issues laid out above. (Event registration, for example, doesn’t feel like a GitHub kind of thing; nor does scheduling tutorials.) If we had a truly programmable web, I could hire a summer student to assemble what I want, but that’s not a yak, it’s a herd of angry mammoths: managing identities and permissions for MailMan, EventBrite, Subversion, and the blog in a single place would require a lot of hacking (or a time machine—if I could go back to 1999 and persuade the startup I was part of to open source SelectAccess, we’d be done by now).

So that leaves me looking for an off-the-shelf solution which I don’t think exists. If I’m wrong, I’d welcome a pointer—and if there’s something we should be doing that isn’t in the discussion above, I’d welcome a pointer to that too.

If you’d like to join us, there’s still plenty of space—and if you have friends who could use some training in basic software skills, please point them our way.

Background

The widespread reluctance to share published research data is often hypothesized to be due to the authors’ fear that reanalysis may expose errors in their work or may produce conclusions that contradict their own. However, these hypotheses have not previously been studied systematically.

Methods and Findings

We related the reluctance to share research data for reanalysis to 1148 statistically significant results reported in 49 papers published in two major psychology journals. We found the reluctance to share data to be associated with weaker evidence (against the null hypothesis of no effect) and a higher prevalence of apparent errors in the reporting of statistical results. The unwillingness to share data was particularly clear when reporting errors had a bearing on statistical significance.

Conclusions

Our findings on the basis of psychological papers suggest that statistical results are particularly hard to verify when reanalysis is more likely to lead to contrasting conclusions. This highlights the importance of establishing mandatory data archiving policies.

Many thanks to Rose, Neil, and Paul for making it possible.

Feedback from the learners was generally good on the material, the venue and the structure. The most common complaint was that it was hard to follow along at times, and I think there are several areas where we’ll be able to improve the “flow” for future events.

Notably, this was the first bootcamp I’ve attended at which nobody found the room too crowded or the wrong temperature. Result, Newcastle!

Here are the good and bad feedback points. Some points were close duplicates, and I’ve put the additional ones in brackets (e.g. Python was cited three times).

You can find links to the material we used on the page about the bootcamp.