| |
The CodeCon 2009 Program Committee is
pleased to announce the preliminary program
for CodeCon 2009.
BioHack! Track:
Code Track:
BioHack! Track
|
DIY Synthetic
Biology - From Design to Construction with New Model Organisms
|
| presenters |
Kay Aull
Mackenzie Cowell
Jason Morrison
|
| details |
Learn how bioengineering goes from design to construction with a case
study of a binary counter biosystem, and how you can leverage the
community and resources of iGEM and BioBricks by using standard
biological parts in new, DIY-friendly, model organisms.
While synthetic biology's ethics of open source and pragmatics of
encapsulation and reusability will go a long way toward democratizing
genetic engineering, there are still significant barriers to entry for
non-institutional scientists. The use of BioBricks in synthetic
biology goes back several years, though traditionally in organisms
such as E. coli that require expensive or non-trivial preparation,
preservation, and culturing techniques.
We will discuss the process of design in synthetic biology through
a case study of Kay's work engineering a binary counting biological
machine. As Kay's work is conducted in her own lab, we will present
the ongoing work to develop techniques that make the same reusable
BioBrick parts accessible and usable in non-traditional model
organisms that are cheaper, easier, and safer to obtain, culture, and
engineer.
|
|
Homebrew Genetic Testing
- Read your own source code - at home!
|
| presenters |
Kay Aull
Mackenzie Cowell
|
| details |
I put together a genetic engineering lab for the io9.com "Mad
Science Contest". It cost under $500 and fit in my closet. Now I've
turned that equipment to another purpose - homebrew genetic
testing. My father was diagnosed a few years ago with hemochromatosis,
a genetic disorder. He was tested by a commercial lab, but the basic
techniques are simple and within reach of the amateur. You can test
yourself with a few hundred dollars in mail-order supplies and
scavenged kitchen equipment. Learn how.
|
|
Keiki Gels - Visualize DNA -- in a drinking straw!
|
| presenters |
Tito Jankowski
|
| details |
It started with a DNA hack -- gel electrophoresis with supplies from
the grocery store. My first full-size gel was somewhat tricky and
required duct tape. I wanted something small that I could hold in my
hands, raise up to a light, and see my DNA bands. Apparently no
serious scientist has ever wanted anything like that!
A poster on DIYbio.org suggested that drinking straws might be
worth a shot. Within a few days of his post, I had tried out the idea
and posted pictures, as well as a instructions on OpenWetWare. As
other DIYbio members began to experiment with keiki gels, I realized
the project represented a whole lot more than visualizing DNA. Keiki
gels represent the future of biotech, where individuals from many
different backgrounds come together to create new ideas, new
experiments, and new equipment to meet their needs.
|
Code Track
|
BitTorrent DNA - Effortless BitTorrent deployment
|
| presenters |
Bram Cohen
Arvid Norberg
Justin Knoll
|
| details | BitTorrent DNA is
was created by BitTorrent Inc. for the purposes of making BitTorrent
be used by more professional environments. It has been under
development for the last two years. DNA is quite simply the easiest
way for anyone to do peer to peer distribution. It also features peer
transfers which do timing based congestion control, which allows it to
fill internet pipes without increasing end user latency.
We will demonstrate from scratch creation of a bootstrap installer
for a game which is not otherwise peer to peer enabled. We will also
show analytics of deployments which have happened.
|
|
Distributed Transaction Layer for Google App Engine - Providing transaction semantics across multiple entity groups for applications written in the Google App Engine distributed computing framework
|
| presenters |
Algorithm:
- Daniel Shawcross Wilkerson
- Simon Fredrick-Vicente Goldsmith
Implementation at Google:
- Erick Armbrust
- Ryan Barrett
|
| details | While designing an
application for Google App Engine (GAE), Daniel Wilkerson noticed that
he really needed a transaction layer to maintain the property that a
graph of objects was always a tree. Tree-ness is a global property,
not a local one, so he needed transaction semantics, and he needed it
across multiple entity groups. Dan had never taken a class in
databases so he had to go learn the subject. He then designed the
algorithm with the help of his friend Simon Goldsmith. Ryan Barrett at
Google thought distributed transactions would be a useful thing for
GAE to have and kindly reviewed the algorithm, finding one missed
optimization opportunity. Erick Armbrust at Google implemented it,
also finding an important correctness bug that Dan fixed.
|
|
Helios Voting
- The first and only web-based voting system that enables voters to verify their vote and the overall tally with cryptographic certainty.
|
| presenters |
Ben Adida
|
| details | Secret-ballot
elections are difficult to secure. Voters need confirmation that their
vote was correctly captured and that all captured votes were correctly
tallied. Meanwhile, individual votes must remain secret. Over the last
25 years, theoretical protocols have been developed to address these
requirements. In the last few years, some in-person systems have been
prototyped.
Helios is the first web-based verifiable voting
implementation. Votes are captured in a web browser, encrypted inside
the browser using a combination of JavaScript and Java, sent to a
tallying server which cryptographically combines the results into an
encrypted tally, which is then decrypted by trustees.
Helios was initially implemented on Google App Engine. It is now
built on Django, and is compatible with Firefox 2/3, Safari 3, and IE
7.
Helios has been used by the Information Card Foundation, and will
be used in March 2009 for the Université Catholique de Louvain's
25,000-voter election.
|
|
Libevent - making fast asynchronous network programs portable
|
| presenters |
Nick Mathewson
Niels Provos
|
| details |
Libevent development started in 2000 in an attempt to provide a
definitive interface to the various high-performance asynchronous
etworking IO backends, like BSD's kqueue, Linux's epoll, and Solaris's
/dev/poll and event ports, while getting the least awful performance
possible on systems that only provide poll or select.
Libevent grew over the years to include an adjunct library with
basic support for a few popular protocols, along with rudimentary
Windows support and a decent edge-triggered IO mechanism.
The current Libevent 2.0 development trunk represents the biggest
change to Libevent since the beginning. In addition to the predictable
API deprecations and decent multithreading support, we've revised our
buffered IO layer to support complex filters, take advantage of
Windows's fast (but very non-unixy) asynchronous networking
architecture.
|
|
Pork - Largescale
Automatic Rewriting of C++
|
| presenters |
Taras Glek
|
| details |
Mozilla needs to be able to make large-scale changes to existing code
for various performance and code-quality improvements. At around 3MLOC
of C++ code it's impossible to make widespread changes
manually. Unfortunately, due to complexity of C++ most refactoring
tools do not target C++ and instead tend to target Java and
occasionally C. The complexity of C++ type system and difficulties
introduced by the C preprocessor make it hard to develop C++
refactoring tools. I built the refactoring toolchain by forking the
Elsa/Oink C++ stack (presented at Codecon 2006) to keep more precise
source positions and making it aware of the macro expansion
annotations produced by MCPP.
|
|
OneSwarm - privacy preserving peer-to-peer data sharing
|
| presenters |
Tomas Isdal
Michael Piatek
|
| details |
OneSwarm builds on years of peer-to-peer systems research at the
University of Washington. Our initial work in this area involved
measuring the properties of BitTorrent users (PAM'07) and studying the
effectiveness of incentives in BitTorrent (NSDI'07 and
'08).
Our work underscores how easy it was to collect data about the
download habits of a large fraction of all BitTorrent users. More
troubling was our discovery that third parties are systematically
monitoring P2P networks using techniques that are open to
manipulation.
The goal of the OneSwarm project is to provide users with the
ability to control what information about their data sharing behavior
that is visible to 3rd parities. To enable this, OneSwarm clients
(when operating privately) share data only with trusted friends. When
data is located further away in the network, it is forwarded over
multiple users using source address rewriting to obscure the source
and destination of forwarded data.
|
|
Parallel Web Browser - a web browser for handhelds & multicore laptops
|
| presenters |
Leo Meyerovich
|
| details | Web browsers are
too slow on laptops and 1-2 magnitudes slower on handhelds: we need to
rethink our language and runtimes, and, if we want to exploit Moore's
law going forward, how we use parallel hardware. We've been working
on new algorithms for page-loading bottlenecks since August and are
starting to look at parallel browser scripting languages again to
build around our core components.
Modern browsers exploit coarse-grained parallelism (e.g.,
process-per-tab) but that does not help individual pages. Furthermore,
they provide parallel language constructs that are not intuitive to
average designers (e.g., worker threads), and do not use parallel
algorithms for many dominant library computations (CSS and DOM
manipulation). We made the first parallel CSS/flow layout algorithms
and have compelling ideas to build upon them. Typical efforts to
parallelize code (in the HPC space) are for much bigger, longer, and
seemingly more static computations than what we see in a web page;
getting any results, in a way, is surprising and promising.
|
|
Switzerland - a semi-P2P system for detecting forged and modified IP packets between clients
|
| presenters |
Peter Eckersley
|
| details | EFF was involved
in the first controlled tests of Comcast's use of forged TCP RST
packets in 2007. We observed that it was particularly cumbersome to
run controlled tests for packet injection or modification using
ordinary packet sniffers. Switzerland is a tool to automate this task
to the greatest extent possible. An early alpha was released in 2008,
and a second alpha will be released before CodeCon.
Switzerland is currently the only tool for passively detecting
forged/modified packets in real network traffic. Most of the other
network neutrality tests use synthetic traffic.
|
|
Tahoe, the
Least-Authority Filesystem - a secure, decentralized, fault-tolerant storage network
|
| presenters |
Zooko Wilcox-O'Hearn
Brian Warner
|
| details | Tahoe is
comparable to Freenet, OceanStore, and Mojo Nation. It avoids some of
the trickier problems in this space by limiting the scope: Tahoe
assumes that the set of storage servers is not too large or dynamic,
and that there are enough servers that are at least moderately
reliable. This means it doesn't even *try* to solve the Very Hard
Problem of sharing storage with millions of anonymous strangers, but
on the other hand it does a fine job of sharing storage among a couple
hundred moderately reliable servers, such as a "friendnet" (home
computers operated by your friends and family) or the allmydata.com
commercial grid. On top of this pool of moderately-reliable servers,
Tahoe adds encryption for confidentiality and integrity,
erasure-coding for high reliability, and capabilities for
file-sharing. The "Principle of Least Authority" design means that the
system relies on each component as little as possible -- security
properties such as confidentiality, integrity, and access control are
all guaranteed by the client on its own behalf using cryptography
instead of relying on the servers to cooperate in providing those
properties. To get the reliability properties that it wants the client
*does* require the help of the servers, but by the power of erasure
coding, only a subset of the servers need to perform only moderately
well for the reliability properties to hold. Tahoe is the only open
source project that I know of which offers these sorts of properties
in a practical system that many people use every day.
|
|
TorFlow - A Python-based Tor Research Toolset
|
| presenters |
Mike Perry
|
| details |
TorFlow is a set of Python scripts written to scan the Tor network for
misbehaving, misconfigured, and overloaded Tor nodes. It also contains
a Python library for experimentation with non-standard Tor path
policies, including but not limited to geographic policies,
latency-based policies, distributed reputation-based policies, and
arbitrary divisions of the network. This is all done with an
extensible Python framework that can be instrumented and/or
manipulated at several different layers of abstraction.
|
| Trend Profiler / trend-prof
- aims at finding performance surprises (super-linearities) in C / C++
code based on trends in the runs of the program on small to medium
inputs.
|
| presenters |
Simon Goldsmith
Daniel S. Wilkerson |
| details |
Trend Profiler is a different kind of performance profiler. To see
the difference, consider the following scenario. A programmer runs a
program on many different inputs. For each input and for each line of
code measure the time spent by that line on that input (we just count
"1" for each, but you could attempt to measure any resource: cycles,
memory allocated, etc). Put the resulting measurements into a
"performance matrix" with inputs across the top and lines of code down
the side.
A standard profiler, such as gdb, summarizes each column (input) of
this matrix in a sophisticated way, but does not say much about the
relationship between columns. In contrast, Trend Prof (1) groups rows
(lines of code) that linearly predict each other well and then (2)
constructs a simple power-law model of each row (-group) versus a
phantom row that measures input size (as programmer-specified), and
then ranks the rows according to how expensive (in the resource
measured) that row's line of code is predicted to grow as input size
increases. Trend Prof does much to help increase the signal to noise
ratio, an inherent problem in such statistical techniques. The
technique of Trend Prof is able to find performance bugs, often
super-linearities where linear performance was expected, and, unlike
in traditional profilers, these bugs cannot be swamped by other lines
of code that are doing magnitudes more computation. Even if bugs are
not found, the resulting analysis provides a unique view onto the
structure of a program that the authors find to be somehow very
satisfying.
|
|
Typhon / Scream
|
| presenters |
Mike Leahy
|
| details |
Typhon has been in ongoing development since 2003 and is an
environment used for creation of new audio software, GUI environments,
and game development. Most recently Typhon has been extended to
Google's Android OS and enables cross device (desktop / mobile)
development with one unified component based API. Over the years
Typhon has adopted leading edge industry standards such as the OSGi
component architecture enabling rapid application development using
the Apache Felix OSGi implementation.
Typhon provides a state of the art component oriented environment
based on OSGi and Apache Felix that is cross platform and cross device
capable enabling the deployment of applications for desktop and mobile
devices from a unified API and source code base.
|
|
|