My Dissertation Defense Announcement

Title

Crowdsourcing Health Discoveries: from Anecdotes to Aggregated Self-Experiments

Time & Location

July 26th, 1:00 PM, E14-244

Thesis Supervisor

Frank Moss, Professor of the Practice of Media Arts and Sciences, MIT

Committee

Henry Lieberman, Principle Research Scientist, MIT
Peter Szolovits, Professor of Computer Science and Engineering, MIT

Abstract

Nearly one quarter of US adults read patient-generated health information found on blogs, forums and social media; many say they use this information to influence everyday health decisions. Topics of discussion in online forums are often poorly-addressed by existing, clinical research, so patient’s reported experiences are the only evidence. No rigorous methods exist to help patients leverage anecdotal evidence to make better decisions.

This dissertation reports on multiple prototype systems that help patients augment anecdote with data to improve individual decision making, optimize healthcare delivery, and accelerate research. The web-based systems were developed through a multi-year collaboration with individuals, advocacy organizations, healthcare providers, and biomedical researchers. The result of this work is a new scientific model for crowdsourcing health insights: Aggregated Self-Experiments.

The self-experiment, a type of single-subject (n-of-1) trial, validates the effectiveness of an intervention on a single person. Aggregating the outcomes of multiple trials can improve the efficiency of future trials and enable users to prioritize the sequencing of trials for a given condition. Successful outcomes from many patients will yield evidence to motivate future clinical research. Aggregated Personal Experiments enables user communities to replace anecdotes with repeatable trials that can be run in the context of their daily life. The properties and viability of the model were evaluated through user studies, secondary data analyses, and experience with real-world deployments.

You can check it out at http://www.personalexperiments.org

Clojure Debugging ’13: Emacs, nREPL, and Ritz

[NOTE: The release of cider deprecates much of the content here. I will post an update on Clojure Debugging ’14 early in the near year]

I’m ramping up for a new set of development projects in 2013 and 2014. My 2010 era setup with slime and swank-clojure is unlikely to remain a viable approach throughout the project. I’ve decided it is time to join the nREPL community as well as take advantage of some of architecture innovations there which may make it easier to debug the distributed systems I’m going to be working on.

Features I’m accustomed to from common lisp slime/swank:

Code navigation via Meta-. and Meta-,
Fuzzy completion in editor windows and the repl
Documentation help in mini-buffer
Object inspector. Ability to walk any value in the system
Walkable backtraces with one-key navigation to offending source
Evaluate an expression in a specific frame, inspect result
Easy tracing of functions to the repl or a trace buffer (in emacs)
Trigger a continuable backtrace via watchpoint or breakpoint

Only the first three of these features is available in the stock nrepl. The rest of this post will discuss how to setup a reasonable approximation to this feature set in Emacs using nREPL middleware providers as of May 2013.

Continue reading “Clojure Debugging ’13: Emacs, nREPL, and Ritz” →

Agile Software Metrics

The rise of dynamic software development methodologies such as Extreme Programming or Agile Programming, reflect the inherent dynamism of modern software design. The malleability of software, the rapid evolution of consumer and technology driven requirements, the difficulty of writing accurate specifications given all the unknowns, and the sheer complexity of the software ecosystem itself makes the ancient development waterfall from specification through execution and QA to release a hazardous and mostly futile affair.

Most software developments fail. While the situation has improved over the last decade, this remains mostly true today. Less than a third of all software projects meet their objectives in approximately the time expected. Over 10% of all projects fail without deliver anything, and most of the rest under-deliver, are terribly late, or way over budget.

This blog post is a thinking-out-loud exploration of how modern Agile methods address these problems and how my thinking is evolving with regards to how success is defined and the probability of success maximized.

Continue reading “Agile Software Metrics” →

What can we learn from our E-Mail logs?

Recently I’ve been observing via RescueTime that I spend 3 hours or more hours in my e-mail application most days. However, I don’t have a good breakdown of how much of this is scheduling, looking up information, commenting on something substantive or social discourse. There is a tremendous amount of information locked up in the time-series of e-mail’s sent and received that can provide insight into aspects of my behavior such as focus of attention (time of day e-mail is sent), social relationships (what organizations I interact with in a given week), the density of idea generation, etc. E-mail logs contains a wealth of raw data that can be instrumented to uncover important information about our life.

Our E-mail logs are also rich archive of useful information such as phone numbers, addresses, what we said to someone, when we said something to someone, edits to papers, attachments, etc. With a proper set of tools, many of which have been built for analyzing social media, we can turn this archive into a database of useful information that can significantly enhance e-mail-based instrumentation.

Continue reading “What can we learn from our E-Mail logs?” →

Schema support for Clojure HBase Client now called clojure-hbase-schemas

My github fork of the Clojure library for HBase, clojure-hbase is now deprecated. I’ve extracted the functionality from David Santiago’s original library (with permission) along with a duplicate of his admin functions to create a parallel repository with the schema-oriented API I developed.

The new repository is owned by Compass Labs and can be found here. The library can also be referenced via Maven / Leiningen:

com.compasslabs/clojure-hbase-schemas "0.90.4"

Writing Java plugins for Flume in Clojure

I recently wrote a plugin in Clojure to add to the Cloudera Flume framework. As it was my first time writing a full java class interface I had to learn about the proper use of both proxy and gen-class. Given the poor error reporting at the java-clojure boundary, figuring out what you did wrong if you don’t get every detail exactly right (particularly when loading a class in the plugin’s final environment) can be difficult.

Continue reading “Writing Java plugins for Flume in Clojure” →

New Abstractions for Clojure-HBase

I just pushed Compass Lab’s HBase Client API to my fork of the clojure-hbase library. The API includes support for table schemas (to auto-encode inputs and outputs) and a constraint language that generates filters and calls for Get and Scan operations. We decided to integrate with the existing fork to retain access to the excellent admin functionality already implemented there. We’ll be talking with the original author and see if we’ll merge or split these two API development paths. In the meantime, you can use our fork of clojure-hbase.

Steps and Flows: Higher-order Composition for Clojure-Hadoop

The clojure-hadoop library is an excellent facility for running Clojure functions within the Hadoop MapReduce framework. At Compass Labs we’ve been using its job abstraction for elements of our production flow and found a number of limitations that motivated us to implement extensions to the base library. We’ve promoted this for integration into a new release of clojure-hadoop which should issue shortly.

There are still some design and implementation warts in the current release which should be fixed by ourselves or other users in the coming weeks.

Continue reading “Steps and Flows: Higher-order Composition for Clojure-Hadoop” →

Learning Bayesian statistics with R

I have a bad tendency in my research work to write my own code and libraries from scratch, in large part because I’ve decided to keep most of my coding in Common Lisp to leverage prior tools. However, I’ve recently been given a painful demonstration of how it is often faster to pay the up-front cost to learn the right tool than to rewrite (and maintain) the subsets you think you need. For example, I found myself venturing into Clojure/Java/Hadoop for my commercial work this year as a compromise between Lisp / dynamic language features and integration benefits. This week I’m finding the need to do some rather sophisticated work with graphical models and I need some tools to build and evaluate them.

I’ve looked at a wide variety of open source approaches such as Samiam (no continuous variables), WinBUGS (only windows), OpenBUGS (not quite ready), HBC (inference only), Mallett (OK, but I don’t like Java and doesn’t support all forms of real-valued random variables), Incanter (limited but growing support for graphical models) and R.

Continue reading “Learning Bayesian statistics with R” →

Streamlining Hadoop and Clojure with Maven

Compass Labs is a heavy user of Clojure for analytics and data process. We have been using Stuart Sierra’s excellent clojure-hadoop package for running a wide variety of algorithms derived from dozens of different Java libraries over our datasets on large Elastic MapReduce clusters.

The standard way to build a Jar for mapreduce is to pack all the libraries for a given package into a single jar and upload it to EMR. Unfortunately, building uberjars for Hadoop is a mallet when a small tap is needed.

We recently reached a point where the overhead of uploading large jars causes a noticeable slow down in our development cycle, especially when launching jobs on connections with limited upload bandwidth and with the slower uberjar creation of lein 1.4.

There are (at least) two solutions to this:

Build smaller jars by having projects with dependencies specific to a given job
Cache the dependencies on the cluster and send over your dependency list and pull the set you need into the Distributed Cache at job configuration time.

To allow us to continue to package all our job steps in a single jar, source tree and lein project, we opted for the latter solution which I will now describe.

Continue reading “Streamlining Hadoop and Clojure with Maven” →