----------------
Release 20070917
----------------

Dave Engberg <engberg@gmail.com>
-JavaBean/JavaDoc enhancements

Andrew McGeachie <geech@evernote.com>
-Cocoa/Objective-C support

Ben Maurer <bmaurer@andrew.cmu.edu>
-Python performance enhancements, fastbinary support

Andrew Lutomirski <andy@luto.us>
-Added optional/required keywords for C++ objects
-Added comparison operators for C++ structs

Johan Oskarsson <johan@oksarsson.nu>
-Java findbugs compliance fixes

Paul Saab <ps@powerset.com>
-IPv6 support for TSocket in C++/Python

Kevin Clark <kevin@powerset.com>
-Significant overhaul of Ruby code generation and servers

Simon Forman <sforman@gmail.com>
-TProcessorFactory abstraction for Java servers

Jake Luciani <jakers@gmail.com>
-Perl code generation, libraries, test code

David Reiss <dreiss@stanford.edu>
-strings.h include fix for bzero
-endianness fixes on TBinaryProtocol double serialization
-improved ntohll,htonll implementation

Dan Li <dto@dev.java.net>
-Java TestServer and Tutorial Fixes

Kevin Ko <kevin.s.ko@gmail.com>
-Fix for unnecessary std::string copy construction in Protocol/Exception

Paul Querna <pquerna@apache.org>
-Autoconf error message fix for libevent detection
-clock_gettime implementation for OSX

----------------
Release 20070401
----------------
