cfp registration * program schedule presenters * lists about sponsors home

    CodeCon 2009
 

 

CodeCon 2009 Program

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.