diff --git a/doc/sigplanconf.cls b/doc/sigplanconf.cls
new file mode 100644
index 0000000..d26f89f
--- /dev/null
+++ b/doc/sigplanconf.cls
@@ -0,0 +1,1175 @@
+%-----------------------------------------------------------------------------
+%
+%               LaTeX Class/Style File
+%
+% Name:         sigplanconf.cls
+% Purpose:      A LaTeX 2e class file for SIGPLAN conference proceedings.
+%               This class file supercedes acm_proc_article-sp,
+%               sig-alternate, and sigplan-proc.
+%
+% Author:       Paul C. Anagnostopoulos
+%               Windfall Software
+%               978 371-2316
+%               paul@windfall.com
+%
+% Created:      12 September 2004
+%
+% Revisions:    See end of file.
+%
+%-----------------------------------------------------------------------------
+
+
+\NeedsTeXFormat{LaTeX2e}[1995/12/01]
+\ProvidesClass{sigplanconf}[2007/03/13 v1.5 ACM SIGPLAN Proceedings]
+
+% The following few pages contain LaTeX programming extensions adapted
+% from the ZzTeX macro package.
+
+%                       Token Hackery
+%                       ----- -------
+
+
+\def \@expandaftertwice {\expandafter\expandafter\expandafter}
+\def \@expandafterthrice {\expandafter\expandafter\expandafter\expandafter
+                          \expandafter\expandafter\expandafter}
+
+% This macro discards the next token.
+
+\def \@discardtok #1{}%                                  token
+
+% This macro removes the `pt' following a dimension.
+
+{\catcode `\p = 12 \catcode `\t = 12
+
+\gdef \@remover #1pt{#1}
+
+} % \catcode
+
+% This macro extracts the contents of a macro and returns it as plain text.
+% Usage: \expandafter\@defof \meaning\macro\@mark
+
+\def \@defof #1:->#2\@mark{#2}
+
+%                       Control Sequence Names
+%                       ------- -------- -----
+
+
+\def \@name #1{%                                        {\tokens}
+  \csname \expandafter\@discardtok \string#1\endcsname}
+
+\def \@withname #1#2{%                                  {\command}{\tokens}
+  \expandafter#1\csname \expandafter\@discardtok \string#2\endcsname}
+
+%                       Flags (Booleans)
+%                       ----- ----------
+
+% The boolean literals \@true and \@false are appropriate for use with
+% the \if command, which tests the codes of the next two characters.
+
+\def \@true {TT}
+\def \@false {FL}
+
+\def \@setflag #1=#2{\edef #1{#2}}%              \flag = boolean
+
+%                       IF and Predicates
+%                       -- --- ----------
+
+% A "predicate" is a macro that returns \@true or \@false as its value.
+% Such values are suitable for use with the \if conditional.  For example:
+%
+%   \if \@oddp{\x} <then-clause> \else <else-clause> \fi
+
+% A predicate can be used with \@setflag as follows:
+%
+%   \@setflag \flag = {<predicate>}
+
+% Here are the predicates for TeX's repertoire of conditional
+% commands.  These might be more appropriately interspersed with
+% other definitions in this module, but what the heck.
+% Some additional "obvious" predicates are defined.
+
+\def \@eqlp   #1#2{\ifnum #1 = #2\@true \else \@false \fi}
+\def \@neqlp  #1#2{\ifnum #1 = #2\@false \else \@true \fi}
+\def \@lssp   #1#2{\ifnum #1 < #2\@true \else \@false \fi}
+\def \@gtrp   #1#2{\ifnum #1 > #2\@true \else \@false \fi}
+\def \@zerop  #1{\ifnum #1 = 0\@true \else \@false \fi}
+\def \@onep   #1{\ifnum #1 = 1\@true \else \@false \fi}
+\def \@posp   #1{\ifnum #1 > 0\@true \else \@false \fi}
+\def \@negp   #1{\ifnum #1 < 0\@true \else \@false \fi}
+\def \@oddp   #1{\ifodd #1\@true \else \@false \fi}
+\def \@evenp  #1{\ifodd #1\@false \else \@true \fi}
+\def \@rangep #1#2#3{\if \@orp{\@lssp{#1}{#2}}{\@gtrp{#1}{#3}}\@false \else
+                                                          \@true \fi}
+\def \@tensp  #1{\@rangep{#1}{10}{19}}
+
+\def \@dimeqlp   #1#2{\ifdim #1 = #2\@true \else \@false \fi}
+\def \@dimneqlp  #1#2{\ifdim #1 = #2\@false \else \@true \fi}
+\def \@dimlssp   #1#2{\ifdim #1 < #2\@true \else \@false \fi}
+\def \@dimgtrp   #1#2{\ifdim #1 > #2\@true \else \@false \fi}
+\def \@dimzerop  #1{\ifdim #1 = 0pt\@true \else \@false \fi}
+\def \@dimposp   #1{\ifdim #1 > 0pt\@true \else \@false \fi}
+\def \@dimnegp   #1{\ifdim #1 < 0pt\@true \else \@false \fi}
+
+\def \@vmodep     {\ifvmode \@true \else \@false \fi}
+\def \@hmodep     {\ifhmode \@true \else \@false \fi}
+\def \@mathmodep  {\ifmmode \@true \else \@false \fi}
+\def \@textmodep  {\ifmmode \@false \else \@true \fi}
+\def \@innermodep {\ifinner \@true \else \@false \fi}
+
+\long\def \@codeeqlp #1#2{\if #1#2\@true \else \@false \fi}
+
+\long\def \@cateqlp #1#2{\ifcat #1#2\@true \else \@false \fi}
+
+\long\def \@tokeqlp  #1#2{\ifx #1#2\@true \else \@false \fi}
+\long\def \@xtokeqlp #1#2{\expandafter\ifx #1#2\@true \else \@false \fi}
+
+\long\def \@definedp #1{%
+  \expandafter\ifx \csname \expandafter\@discardtok \string#1\endcsname
+                   \relax \@false \else \@true \fi}
+
+\long\def \@undefinedp #1{%
+  \expandafter\ifx \csname \expandafter\@discardtok \string#1\endcsname
+                   \relax \@true \else \@false \fi}
+
+\def \@emptydefp #1{\ifx #1\@empty \@true \else \@false \fi}%       {\name}
+
+\let \@emptylistp = \@emptydefp
+
+\long\def \@emptyargp #1{%                               {#n}
+  \@empargp #1\@empargq\@mark}
+\long\def \@empargp #1#2\@mark{%
+  \ifx #1\@empargq \@true \else \@false \fi}
+\def \@empargq {\@empargq}
+
+\def \@emptytoksp #1{%                                   {\tokenreg}
+  \expandafter\@emptoksp \the#1\@mark}
+
+\long\def \@emptoksp #1\@mark{\@emptyargp{#1}}
+
+\def \@voidboxp #1{\ifvoid #1\@true \else \@false \fi}
+\def \@hboxp #1{\ifhbox #1\@true \else \@false \fi}
+\def \@vboxp #1{\ifvbox #1\@true \else \@false \fi}
+
+\def \@eofp #1{\ifeof #1\@true \else \@false \fi}
+
+
+% Flags can also be used as predicates, as in:
+%
+%   \if \flaga <then-clause> \else <else-clause> \fi
+
+
+% Now here we have predicates for the common logical operators.
+
+\def \@notp #1{\if #1\@false \else \@true \fi}
+
+\def \@andp #1#2{\if #1%
+                  \if #2\@true \else \@false \fi
+                \else
+                  \@false
+                \fi}
+
+\def \@orp #1#2{\if #1%
+                 \@true
+               \else
+                 \if #2\@true \else \@false \fi
+               \fi}
+
+\def \@xorp #1#2{\if #1%
+                  \if #2\@false \else \@true \fi
+                \else
+                  \if #2\@true \else \@false \fi
+                \fi}
+
+%                       Arithmetic
+%                       ----------
+
+\def \@increment #1{\advance #1 by 1\relax}%             {\count}
+
+\def \@decrement #1{\advance #1 by -1\relax}%            {\count}
+
+%                       Options
+%                       -------
+
+
+\@setflag \@blockstyle = \@false
+\@setflag \@copyrightwanted = \@true
+\@setflag \@explicitsize = \@false
+\@setflag \@mathtime = \@false
+\@setflag \@ninepoint = \@true
+\newcount{\@numheaddepth} \@numheaddepth = 3
+\@setflag \@onecolumn = \@false
+\@setflag \@preprint = \@false
+\@setflag \@reprint = \@false
+\@setflag \@times = \@false
+
+% Note that all the dangerous article class options are trapped.
+
+\DeclareOption{9pt}{\@setflag \@ninepoint = \@true
+                    \@setflag \@explicitsize = \@true}
+
+\DeclareOption{10pt}{\PassOptionsToClass{10pt}{article}%
+                     \@setflag \@ninepoint = \@false
+                     \@setflag \@explicitsize = \@true}
+
+\DeclareOption{11pt}{\PassOptionsToClass{11pt}{article}%
+                     \@setflag \@ninepoint = \@false
+                     \@setflag \@explicitsize = \@true}
+
+\DeclareOption{12pt}{\@unsupportedoption{12pt}}
+
+\DeclareOption{a4paper}{\@unsupportedoption{a4paper}}
+
+\DeclareOption{a5paper}{\@unsupportedoption{a5paper}}
+
+\DeclareOption{b5paper}{\@unsupportedoption{b5paper}}
+
+\DeclareOption{blockstyle}{\@setflag \@blockstyle = \@true}
+
+\DeclareOption{cm}{\@setflag \@times = \@false}
+
+\DeclareOption{computermodern}{\@setflag \@times = \@false}
+
+\DeclareOption{executivepaper}{\@unsupportedoption{executivepaper}}
+
+\DeclareOption{indentedstyle}{\@setflag \@blockstyle = \@false}
+
+\DeclareOption{landscape}{\@unsupportedoption{landscape}}
+
+\DeclareOption{legalpaper}{\@unsupportedoption{legalpaper}}
+
+\DeclareOption{letterpaper}{\@unsupportedoption{letterpaper}}
+
+\DeclareOption{mathtime}{\@setflag \@mathtime = \@true}
+
+\DeclareOption{nocopyrightspace}{\@setflag \@copyrightwanted = \@false}
+
+\DeclareOption{notitlepage}{\@unsupportedoption{notitlepage}}
+
+\DeclareOption{numberedpars}{\@numheaddepth = 4}
+
+%%%\DeclareOption{onecolumn}{\@setflag \@onecolumn = \@true}
+
+\DeclareOption{preprint}{\@setflag \@preprint = \@true}
+
+\DeclareOption{reprint}{\@setflag \@reprint = \@true}
+
+\DeclareOption{times}{\@setflag \@times = \@true}
+
+\DeclareOption{titlepage}{\@unsupportedoption{titlepage}}
+
+\DeclareOption{twocolumn}{\@setflag \@onecolumn = \@false}
+
+\DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
+
+\ExecuteOptions{9pt,indentedstyle,times}
+\@setflag \@explicitsize = \@false
+\ProcessOptions
+
+\if \@onecolumn
+  \if \@notp{\@explicitsize}%
+    \@setflag \@ninepoint = \@false
+    \PassOptionsToClass{11pt}{article}%
+  \fi
+  \PassOptionsToClass{twoside,onecolumn}{article}
+\else
+  \PassOptionsToClass{twoside,twocolumn}{article}
+\fi
+\LoadClass{article}
+
+\def \@unsupportedoption #1{%
+  \ClassError{proc}{The standard '#1' option is not supported.}}
+
+% This can be used with the 'reprint' option to get the final folios.
+
+\def \setpagenumber #1{%
+  \setcounter{page}{#1}}
+
+\AtEndDocument{\label{sigplanconf@finalpage}}
+
+%                       Utilities
+%                       ---------
+
+
+\newcommand{\setvspace}[2]{%
+  #1 = #2
+  \advance #1 by -1\parskip}
+
+%                       Document Parameters
+%                       -------- ----------
+
+
+% Page:
+
+\setlength{\hoffset}{-1in}
+\setlength{\voffset}{-1in}
+
+\setlength{\topmargin}{1in}
+\setlength{\headheight}{0pt}
+\setlength{\headsep}{0pt}
+
+\if \@onecolumn
+  \setlength{\evensidemargin}{.75in}
+  \setlength{\oddsidemargin}{.75in}
+\else
+  \setlength{\evensidemargin}{.75in}
+  \setlength{\oddsidemargin}{.75in}
+\fi
+
+% Text area:
+
+\newdimen{\standardtextwidth}
+\setlength{\standardtextwidth}{42pc}
+
+\if \@onecolumn
+  \setlength{\textwidth}{40.5pc}
+\else
+  \setlength{\textwidth}{\standardtextwidth}
+\fi
+
+\setlength{\topskip}{8pt}
+\setlength{\columnsep}{2pc}
+\setlength{\textheight}{54.5pc}
+
+% Running foot:
+
+\setlength{\footskip}{30pt}
+
+% Paragraphs:
+
+\if \@blockstyle
+  \setlength{\parskip}{5pt plus .1pt minus .5pt}
+  \setlength{\parindent}{0pt}
+\else
+  \setlength{\parskip}{0pt}
+  \setlength{\parindent}{12pt}
+\fi
+
+\setlength{\lineskip}{.5pt}
+\setlength{\lineskiplimit}{\lineskip}
+
+\frenchspacing
+\pretolerance = 400
+\tolerance = \pretolerance
+\setlength{\emergencystretch}{5pt}
+\clubpenalty = 10000
+\widowpenalty = 10000
+\setlength{\hfuzz}{.5pt}
+
+% Standard vertical spaces:
+
+\newskip{\standardvspace}
+\setvspace{\standardvspace}{5pt plus 1pt minus .5pt}
+
+% Margin paragraphs:
+
+\setlength{\marginparwidth}{36pt}
+\setlength{\marginparsep}{2pt}
+\setlength{\marginparpush}{8pt}
+
+
+\setlength{\skip\footins}{8pt plus 3pt minus 1pt}
+\setlength{\footnotesep}{9pt}
+
+\renewcommand{\footnoterule}{%
+  \hrule width .5\columnwidth height .33pt depth 0pt}
+
+\renewcommand{\@makefntext}[1]{%
+  \noindent \@makefnmark \hspace{1pt}#1}
+
+% Floats:
+
+\setcounter{topnumber}{4}
+\setcounter{bottomnumber}{1}
+\setcounter{totalnumber}{4}
+
+\renewcommand{\fps@figure}{tp}
+\renewcommand{\fps@table}{tp}
+\renewcommand{\topfraction}{0.90}
+\renewcommand{\bottomfraction}{0.30}
+\renewcommand{\textfraction}{0.10}
+\renewcommand{\floatpagefraction}{0.75}
+
+\setcounter{dbltopnumber}{4}
+
+\renewcommand{\dbltopfraction}{\topfraction}
+\renewcommand{\dblfloatpagefraction}{\floatpagefraction}
+
+\setlength{\floatsep}{18pt plus 4pt minus 2pt}
+\setlength{\textfloatsep}{18pt plus 4pt minus 3pt}
+\setlength{\intextsep}{10pt plus 4pt minus 3pt}
+
+\setlength{\dblfloatsep}{18pt plus 4pt minus 2pt}
+\setlength{\dbltextfloatsep}{20pt plus 4pt minus 3pt}
+
+% Miscellaneous:
+
+\errorcontextlines = 5
+
+%                       Fonts
+%                       -----
+
+
+\if \@times
+  \renewcommand{\rmdefault}{ptm}%
+  \if \@mathtime
+    \usepackage[mtbold,noTS1]{mathtime}%
+  \else
+%%%    \usepackage{mathptm}%
+  \fi
+\else
+  \relax
+\fi
+
+\if \@ninepoint
+
+\renewcommand{\normalsize}{%
+  \@setfontsize{\normalsize}{9pt}{10pt}%
+  \setlength{\abovedisplayskip}{5pt plus 1pt minus .5pt}%
+  \setlength{\belowdisplayskip}{\abovedisplayskip}%
+  \setlength{\abovedisplayshortskip}{3pt plus 1pt minus 2pt}%
+  \setlength{\belowdisplayshortskip}{\abovedisplayshortskip}}
+
+\renewcommand{\tiny}{\@setfontsize{\tiny}{5pt}{6pt}}
+
+\renewcommand{\scriptsize}{\@setfontsize{\scriptsize}{7pt}{8pt}}
+
+\renewcommand{\small}{%
+  \@setfontsize{\small}{8pt}{9pt}%
+  \setlength{\abovedisplayskip}{4pt plus 1pt minus 1pt}%
+  \setlength{\belowdisplayskip}{\abovedisplayskip}%
+  \setlength{\abovedisplayshortskip}{2pt plus 1pt}%
+  \setlength{\belowdisplayshortskip}{\abovedisplayshortskip}}
+
+\renewcommand{\footnotesize}{%
+  \@setfontsize{\footnotesize}{8pt}{9pt}%
+  \setlength{\abovedisplayskip}{4pt plus 1pt minus .5pt}%
+  \setlength{\belowdisplayskip}{\abovedisplayskip}%
+  \setlength{\abovedisplayshortskip}{2pt plus 1pt}%
+  \setlength{\belowdisplayshortskip}{\abovedisplayshortskip}}
+
+\renewcommand{\large}{\@setfontsize{\large}{11pt}{13pt}}
+
+\renewcommand{\Large}{\@setfontsize{\Large}{14pt}{18pt}}
+
+\renewcommand{\LARGE}{\@setfontsize{\LARGE}{18pt}{20pt}}
+
+\renewcommand{\huge}{\@setfontsize{\huge}{20pt}{25pt}}
+
+\renewcommand{\Huge}{\@setfontsize{\Huge}{25pt}{30pt}}
+
+\fi
+
+%                       Abstract
+%                       --------
+
+
+\renewenvironment{abstract}{%
+  \section*{Abstract}%
+  \normalsize}{%
+  }
+
+%                       Bibliography
+%                       ------------
+
+
+\renewenvironment{thebibliography}[1]
+     {\section*{\refname
+        \@mkboth{\MakeUppercase\refname}{\MakeUppercase\refname}}%
+      \list{\@biblabel{\@arabic\c@enumiv}}%
+           {\settowidth\labelwidth{\@biblabel{#1}}%
+            \leftmargin\labelwidth
+            \advance\leftmargin\labelsep
+            \@openbib@code
+            \usecounter{enumiv}%
+            \let\p@enumiv\@empty
+            \renewcommand\theenumiv{\@arabic\c@enumiv}}%
+      \small
+      \softraggedright%%%\sloppy
+      \clubpenalty4000
+      \@clubpenalty \clubpenalty
+      \widowpenalty4000%
+      \sfcode`\.\@m}
+     {\def\@noitemerr
+       {\@latex@warning{Empty `thebibliography' environment}}%
+      \endlist}
+
+%                       Categories
+%                       ----------
+
+
+\@setflag \@firstcategory = \@true
+
+\newcommand{\category}[3]{%
+  \if \@firstcategory
+    \paragraph*{Categories and Subject Descriptors}%
+    \@setflag \@firstcategory = \@false
+  \else
+    \unskip ;\hspace{.75em}%
+  \fi
+  \@ifnextchar [{\@category{#1}{#2}{#3}}{\@category{#1}{#2}{#3}[]}}
+
+\def \@category #1#2#3[#4]{%
+  {\let \and = \relax
+   #1 [\textit{#2}]%
+   \if \@emptyargp{#4}%
+     \if \@notp{\@emptyargp{#3}}: #3\fi
+   \else
+     :\space
+     \if \@notp{\@emptyargp{#3}}#3---\fi
+     \textrm{#4}%
+   \fi}}
+
+%                       Copyright Notice
+%                       --------- ------
+
+
+\def \ftype@copyrightbox {8}
+\def \@toappear {}
+\def \@permission {}
+
+
+\def \@copyrightspace {%
+  \@float{copyrightbox}[b]%
+  \vbox to 1in{%
+    \vfill
+    \parbox[b]{20pc}{%
+      \scriptsize
+      \if \@preprint
+        [Copyright notice will appear here
+         once 'preprint' option is removed.]\par
+      \else
+        \@toappear
+      \fi
+      \if \@reprint
+        \noindent Reprinted from \@conferencename,
+        \@proceedings,
+        \@conferenceinfo,
+        pp.~\number\thepage--\pageref{sigplanconf@finalpage}.\par
+      \fi}}%
+  \end@float}
+
+\long\def \toappear #1{%
+  \def \@toappear {#1}}
+
+\toappear{%
+  \noindent \@permission \par
+  \vspace{2pt}
+  \noindent \textsl{\@conferencename}\quad \@conferenceinfo \par
+  \noindent Copyright \copyright\ \@copyrightyear\ ACM \@copyrightdata
+    \dots \$5.00\par}
+
+\newcommand{\permission}[1]{%
+  \gdef \@permission {#1}}
+
+\permission{%
+  Permission to make digital or hard copies of all or
+  part of this work for personal or classroom use is granted without
+  fee provided that copies are not made or distributed for profit or
+  commercial advantage and that copies bear this notice and the full
+  citation on the first page.  To copy otherwise, to republish, to
+  post on servers or to redistribute to lists, requires prior specific
+  permission and/or a fee.}
+
+% Here we have some alternate permission statements and copyright lines:
+
+\newcommand{\ACMCanadapermission}{%
+  \permission{%
+    Copyright \@copyrightyear\ Association for Computing Machinery.
+    ACM acknowledges that
+    this contribution was authored or co-authored by an affiliate of the
+    National Research Council of Canada (NRC).
+    As such, the Crown in Right of
+    Canada retains an equal interest in the copyright, however granting
+    nonexclusive, royalty-free right to publish or reproduce this article,
+    or to allow others to do so, provided that clear attribution
+    is also given to the authors and the NRC.}}
+
+\newcommand{\ACMUSpermission}{%
+  \permission{%
+    Copyright \@copyrightyear\ Association for
+    Computing Machinery. ACM acknowledges that
+    this contribution was authored or co-authored
+    by a contractor or affiliate
+    of the U.S. Government. As such, the Government retains a nonexclusive,
+    royalty-free right to publish or reproduce this article,
+    or to allow others to do so, for Government purposes only.}}
+
+\newcommand{\authorpermission}{%
+  \permission{%
+    Copyright is held by the author/owner(s).}
+  \toappear{%
+    \noindent \@permission \par
+    \vspace{2pt}
+    \noindent \textsl{\@conferencename}\quad \@conferenceinfo \par
+    ACM \@copyrightdata.}}
+
+\newcommand{\Sunpermission}{%
+  \permission{%
+    Copyright is held by Sun Microsystems, Inc.}%
+  \toappear{%
+    \noindent \@permission \par
+    \vspace{2pt}
+    \noindent \textsl{\@conferencename}\quad \@conferenceinfo \par
+    ACM \@copyrightdata.}}
+
+\newcommand{\USpublicpermission}{%
+  \permission{%
+    This paper is authored by an employee(s) of the United States
+    Government and is in the public domain.}%
+  \toappear{%
+    \noindent \@permission \par
+    \vspace{2pt}
+    \noindent \textsl{\@conferencename}\quad \@conferenceinfo \par
+    ACM \@copyrightdata.}}
+
+%                       Enunciations
+%                       ------------
+
+
+\def \@begintheorem #1#2{%                      {name}{number}
+  \trivlist
+  \item[\hskip \labelsep \textsc{#1 #2.}]%
+  \itshape\selectfont
+  \ignorespaces}
+
+\def \@opargbegintheorem #1#2#3{%               {name}{number}{title}
+  \trivlist
+  \item[%
+    \hskip\labelsep \textsc{#1\ #2}%
+    \if \@notp{\@emptyargp{#3}}\nut (#3).\fi]%
+  \itshape\selectfont
+  \ignorespaces}
+
+%                       Figures
+%                       -------
+
+
+\@setflag \@caprule = \@true
+
+\long\def \@makecaption #1#2{%
+  \addvspace{4pt}
+  \if \@caprule
+    \hrule width \hsize height .33pt
+    \vspace{4pt}
+  \fi
+  \setbox \@tempboxa = \hbox{\@setfigurenumber{#1.}\nut #2}%
+  \if \@dimgtrp{\wd\@tempboxa}{\hsize}%
+    \noindent \@setfigurenumber{#1.}\nut #2\par
+  \else
+    \centerline{\box\@tempboxa}%
+  \fi}
+
+\newcommand{\nocaptionrule}{%
+  \@setflag \@caprule = \@false}
+
+\def \@setfigurenumber #1{%
+  {\rmfamily \bfseries \selectfont #1}}
+
+%                       Hierarchy
+%                       ---------
+
+
+\setcounter{secnumdepth}{\@numheaddepth}
+
+\newskip{\@sectionaboveskip}
+\setvspace{\@sectionaboveskip}{10pt plus 3pt minus 2pt}
+
+\newskip{\@sectionbelowskip}
+\if \@blockstyle
+  \setlength{\@sectionbelowskip}{0.1pt}%
+\else
+  \setlength{\@sectionbelowskip}{4pt}%
+\fi
+
+\renewcommand{\section}{%
+  \@startsection
+    {section}%
+    {1}%
+    {0pt}%
+    {-\@sectionaboveskip}%
+    {\@sectionbelowskip}%
+    {\large \bfseries \raggedright}}
+
+\newskip{\@subsectionaboveskip}
+\setvspace{\@subsectionaboveskip}{8pt plus 2pt minus 2pt}
+
+\newskip{\@subsectionbelowskip}
+\if \@blockstyle
+  \setlength{\@subsectionbelowskip}{0.1pt}%
+\else
+  \setlength{\@subsectionbelowskip}{4pt}%
+\fi
+
+\renewcommand{\subsection}{%
+  \@startsection%
+    {subsection}%
+    {2}%
+    {0pt}%
+    {-\@subsectionaboveskip}%
+    {\@subsectionbelowskip}%
+    {\normalsize \bfseries \raggedright}}
+
+\renewcommand{\subsubsection}{%
+  \@startsection%
+    {subsubsection}%
+    {3}%
+    {0pt}%
+    {-\@subsectionaboveskip}
+    {\@subsectionbelowskip}%
+    {\normalsize \bfseries \raggedright}}
+
+\newskip{\@paragraphaboveskip}
+\setvspace{\@paragraphaboveskip}{6pt plus 2pt minus 2pt}
+
+\renewcommand{\paragraph}{%
+  \@startsection%
+    {paragraph}%
+    {4}%
+    {0pt}%
+    {\@paragraphaboveskip}
+    {-1em}%
+    {\normalsize \bfseries \if \@times \itshape \fi}}
+
+\renewcommand{\subparagraph}{%
+  \@startsection%
+    {subparagraph}%
+    {4}%
+    {0pt}%
+    {\@paragraphaboveskip}
+    {-1em}%
+    {\normalsize \itshape}}
+
+% Standard headings:
+
+\newcommand{\acks}{\section*{Acknowledgments}}
+
+\newcommand{\keywords}{\paragraph*{Keywords}}
+
+\newcommand{\terms}{\paragraph*{General Terms}}
+
+%                       Identification
+%                       --------------
+
+
+\def \@conferencename {}
+\def \@conferenceinfo {}
+\def \@copyrightyear {}
+\def \@copyrightdata {[to be supplied]}
+\def \@proceedings {[Unknown Proceedings]}
+
+
+\newcommand{\conferenceinfo}[2]{%
+  \gdef \@conferencename {#1}%
+  \gdef \@conferenceinfo {#2}}
+
+\newcommand{\copyrightyear}[1]{%
+  \gdef \@copyrightyear {#1}}
+
+\let \CopyrightYear = \copyrightyear
+
+\newcommand{\copyrightdata}[1]{%
+  \gdef \@copyrightdata {#1}}
+
+\let \crdata = \copyrightdata
+
+\newcommand{\proceedings}[1]{%
+  \gdef \@proceedings {#1}}
+
+%                       Lists
+%                       -----
+
+
+\setlength{\leftmargini}{13pt}
+\setlength\leftmarginii{13pt}
+\setlength\leftmarginiii{13pt}
+\setlength\leftmarginiv{13pt}
+\setlength{\labelsep}{3.5pt}
+
+\setlength{\topsep}{\standardvspace}
+\if \@blockstyle
+  \setlength{\itemsep}{1pt}
+  \setlength{\parsep}{3pt}
+\else
+  \setlength{\itemsep}{1pt}
+  \setlength{\parsep}{3pt}
+\fi
+
+\renewcommand{\labelitemi}{{\small \centeroncapheight{\textbullet}}}
+\renewcommand{\labelitemii}{\centeroncapheight{\rule{2.5pt}{2.5pt}}}
+\renewcommand{\labelitemiii}{$-$}
+\renewcommand{\labelitemiv}{{\Large \textperiodcentered}}
+
+\renewcommand{\@listi}{%
+  \leftmargin = \leftmargini
+  \listparindent = 0pt}
+%%%  \itemsep = 1pt
+%%%  \parsep = 3pt}
+%%%  \listparindent = \parindent}
+
+\let \@listI = \@listi
+
+\renewcommand{\@listii}{%
+  \leftmargin = \leftmarginii
+  \topsep = 1pt
+  \labelwidth = \leftmarginii
+  \advance \labelwidth by -\labelsep
+  \listparindent = \parindent}
+
+\renewcommand{\@listiii}{%
+  \leftmargin = \leftmarginiii
+  \labelwidth = \leftmarginiii
+  \advance \labelwidth by -\labelsep
+  \listparindent = \parindent}
+
+\renewcommand{\@listiv}{%
+  \leftmargin = \leftmarginiv
+  \labelwidth = \leftmarginiv
+  \advance \labelwidth by -\labelsep
+  \listparindent = \parindent}
+
+%                       Mathematics
+%                       -----------
+
+
+\def \theequation {\arabic{equation}}
+
+%                       Miscellaneous
+%                       -------------
+
+
+\newcommand{\balancecolumns}{%
+  \vfill\eject
+  \global\@colht = \textheight
+  \global\ht\@cclv = \textheight}
+
+\newcommand{\nut}{\hspace{.5em}}
+
+\newcommand{\softraggedright}{%
+  \let \\ = \@centercr
+  \leftskip = 0pt
+  \rightskip = 0pt plus 10pt}
+
+%                       Program Code
+%                       ------- ----
+
+
+\newcommand{\mono}[1]{%
+  {\@tempdima = \fontdimen2\font
+   \texttt{\spaceskip = 1.1\@tempdima #1}}}
+
+%                       Running Heads and Feet
+%                       ------- ----- --- ----
+
+
+\def \@preprintfooter {}
+
+\newcommand{\preprintfooter}[1]{%
+  \gdef \@preprintfooter {#1}}
+
+\if \@preprint
+
+\def \ps@plain {%
+  \let \@mkboth = \@gobbletwo
+  \let \@evenhead = \@empty
+  \def \@evenfoot {\scriptsize \textit{\@preprintfooter}\hfil \thepage \hfil
+                   \textit{\@formatyear}}%
+  \let \@oddhead = \@empty
+  \let \@oddfoot = \@evenfoot}
+
+\else\if \@reprint
+
+\def \ps@plain {%
+  \let \@mkboth = \@gobbletwo
+  \let \@evenhead = \@empty
+  \def \@evenfoot {\scriptsize \hfil \thepage \hfil}%
+  \let \@oddhead = \@empty
+  \let \@oddfoot = \@evenfoot}
+
+\else
+
+\let \ps@plain = \ps@empty
+\let \ps@headings = \ps@empty
+\let \ps@myheadings = \ps@empty
+
+\fi\fi
+
+\def \@formatyear {%
+  \number\year/\number\month/\number\day}
+
+%                       Special Characters
+%                       ------- ----------
+
+
+\DeclareRobustCommand{\euro}{%
+  \protect{\rlap{=}}{\sf \kern .1em C}}
+
+%                       Title Page
+%                       ----- ----
+
+
+\@setflag \@addauthorsdone = \@false
+
+\def \@titletext {\@latex@error{No title was provided}{}}
+\def \@subtitletext {}
+
+\newcount{\@authorcount}
+
+\newcount{\@titlenotecount}
+\newtoks{\@titlenotetext}
+
+\def \@titlebanner {}
+
+\renewcommand{\title}[1]{%
+  \gdef \@titletext {#1}}
+
+\newcommand{\subtitle}[1]{%
+  \gdef \@subtitletext {#1}}
+
+\newcommand{\authorinfo}[3]{%           {names}{affiliation}{email/URL}
+  \global\@increment \@authorcount
+  \@withname\gdef {\@authorname\romannumeral\@authorcount}{#1}%
+  \@withname\gdef {\@authoraffil\romannumeral\@authorcount}{#2}%
+  \@withname\gdef {\@authoremail\romannumeral\@authorcount}{#3}}
+
+\renewcommand{\author}[1]{%
+  \@latex@error{The \string\author\space command is obsolete;
+                use \string\authorinfo}{}}
+
+\newcommand{\titlebanner}[1]{%
+  \gdef \@titlebanner {#1}}
+
+\renewcommand{\maketitle}{%
+  \pagestyle{plain}%
+  \if \@onecolumn
+    {\hsize = \standardtextwidth
+     \@maketitle}%
+  \else
+    \twocolumn[\@maketitle]%
+  \fi
+  \@placetitlenotes
+  \if \@copyrightwanted \@copyrightspace \fi}
+
+\def \@maketitle {%
+  \begin{center}
+  \@settitlebanner
+  \let \thanks = \titlenote
+  \noindent \LARGE \bfseries \@titletext \par
+  \vskip 6pt
+  \noindent \Large \@subtitletext \par
+  \vskip 12pt
+  \ifcase \@authorcount
+    \@latex@error{No authors were specified for this paper}{}\or
+    \@titleauthors{i}{}{}\or
+    \@titleauthors{i}{ii}{}\or
+    \@titleauthors{i}{ii}{iii}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{}{}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}%
+                  \@titleauthors{vii}{}{}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}%
+                  \@titleauthors{vii}{viii}{}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}%
+                  \@titleauthors{vii}{viii}{ix}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}%
+                  \@titleauthors{vii}{viii}{ix}\@titleauthors{x}{}{}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}%
+                  \@titleauthors{vii}{viii}{ix}\@titleauthors{x}{xi}{}\or
+    \@titleauthors{i}{ii}{iii}\@titleauthors{iv}{v}{vi}%
+                  \@titleauthors{vii}{viii}{ix}\@titleauthors{x}{xi}{xii}%
+  \else
+    \@latex@error{Cannot handle more than 12 authors}{}%
+  \fi
+  \vspace{1.75pc}
+  \end{center}}
+
+\def \@settitlebanner {%
+  \if \@andp{\@preprint}{\@notp{\@emptydefp{\@titlebanner}}}%
+    \vbox to 0pt{%
+      \vskip -32pt
+      \noindent \textbf{\@titlebanner}\par
+      \vss}%
+    \nointerlineskip
+  \fi}
+
+\def \@titleauthors #1#2#3{%
+  \if \@andp{\@emptyargp{#2}}{\@emptyargp{#3}}%
+    \noindent \@setauthor{40pc}{#1}{\@false}\par
+  \else\if \@emptyargp{#3}%
+    \noindent \@setauthor{17pc}{#1}{\@false}\hspace{3pc}%
+              \@setauthor{17pc}{#2}{\@false}\par
+  \else
+    \noindent \@setauthor{12.5pc}{#1}{\@false}\hspace{2pc}%
+              \@setauthor{12.5pc}{#2}{\@false}\hspace{2pc}%
+              \@setauthor{12.5pc}{#3}{\@true}\par
+    \relax
+  \fi\fi
+  \vspace{20pt}}
+
+\def \@setauthor #1#2#3{%                       {width}{text}{unused}
+  \vtop{%
+    \def \and {%
+      \hspace{16pt}}
+    \hsize = #1
+    \normalfont
+    \centering
+    \large \@name{\@authorname#2}\par
+    \vspace{5pt}
+    \normalsize \@name{\@authoraffil#2}\par
+    \vspace{4pt}
+    \normalsize{\@name{\@authoremail#2}}\par}}
+
+\def \@maybetitlenote #1{%
+  \if \@andp{#1}{\@gtrp{\@authorcount}{3}}%
+    \titlenote{See page~\pageref{@addauthors} for additional authors.}%
+  \fi}
+
+\newtoks{\@fnmark}
+
+\newcommand{\titlenote}[1]{%
+  \global\@increment \@titlenotecount
+  \ifcase \@titlenotecount \relax \or
+    \@fnmark = {\ast}\or
+    \@fnmark = {\dagger}\or
+    \@fnmark = {\ddagger}\or
+    \@fnmark = {\S}\or
+    \@fnmark = {\P}\or
+    \@fnmark = {\ast\ast}%
+  \fi
+  \,$^{\the\@fnmark}$%
+  \edef \reserved@a {\noexpand\@appendtotext{%
+                       \noexpand\@titlefootnote{\the\@fnmark}}}%
+  \reserved@a{#1}}
+
+\def \@appendtotext #1#2{%
+  \global\@titlenotetext = \expandafter{\the\@titlenotetext #1{#2}}}
+
+\newcount{\@authori}
+
+\iffalse
+\def \additionalauthors {%
+  \if \@gtrp{\@authorcount}{3}%
+    \section{Additional Authors}%
+    \label{@addauthors}%
+    \noindent
+    \@authori = 4
+    {\let \\ = ,%
+     \loop 
+       \textbf{\@name{\@authorname\romannumeral\@authori}},
+       \@name{\@authoraffil\romannumeral\@authori},
+       email: \@name{\@authoremail\romannumeral\@authori}.%
+       \@increment \@authori
+     \if \@notp{\@gtrp{\@authori}{\@authorcount}} \repeat}%
+    \par
+  \fi
+  \global\@setflag \@addauthorsdone = \@true}
+\fi
+
+\let \addauthorsection = \additionalauthors
+
+\def \@placetitlenotes {
+  \the\@titlenotetext}
+
+%                       Utilities
+%                       ---------
+
+
+\newcommand{\centeroncapheight}[1]{%
+  {\setbox\@tempboxa = \hbox{#1}%
+   \@measurecapheight{\@tempdima}%         % Calculate ht(CAP) - ht(text)
+   \advance \@tempdima by -\ht\@tempboxa   %           ------------------
+   \divide \@tempdima by 2                 %                   2
+   \raise \@tempdima \box\@tempboxa}}
+
+\newbox{\@measbox}
+
+\def \@measurecapheight #1{%                            {\dimen}
+  \setbox\@measbox = \hbox{ABCDEFGHIJKLMNOPQRSTUVWXYZ}%
+  #1 = \ht\@measbox}
+
+\long\def \@titlefootnote #1#2{%
+  \insert\footins{%
+    \reset@font\footnotesize
+    \interlinepenalty\interfootnotelinepenalty
+    \splittopskip\footnotesep
+    \splitmaxdepth \dp\strutbox \floatingpenalty \@MM
+    \hsize\columnwidth \@parboxrestore
+%%%    \protected@edef\@currentlabel{%
+%%%       \csname p@footnote\endcsname\@thefnmark}%
+    \color@begingroup
+      \def \@makefnmark {$^{#1}$}%
+      \@makefntext{%
+        \rule\z@\footnotesep\ignorespaces#2\@finalstrut\strutbox}%
+    \color@endgroup}}
+
+%                       LaTeX Modifications
+%                       ----- -------------
+
+\def \@seccntformat #1{%
+  \@name{\the#1}%
+  \@expandaftertwice\@seccntformata \csname the#1\endcsname.\@mark
+  \quad}
+
+\def \@seccntformata #1.#2\@mark{%
+  \if \@emptyargp{#2}.\fi}
+
+%                       Revision History
+%                       -------- -------
+
+
+%  Date         Person  Ver.    Change
+%  ----         ------  ----    ------
+
+%  2004.09.12   PCA     0.1--5  Preliminary development.
+
+%  2004.11.18   PCA     0.5     Start beta testing.
+
+%  2004.11.19   PCA     0.6     Obsolete \author and replace with
+%                               \authorinfo.
+%                               Add 'nocopyrightspace' option.
+%                               Compress article opener spacing.
+%                               Add 'mathtime' option.
+%                               Increase text height by 6 points.
+
+%  2004.11.28   PCA     0.7     Add 'cm/computermodern' options.
+%                               Change default to Times text.
+
+%  2004.12.14   PCA     0.8     Remove use of mathptm.sty; it cannot
+%                               coexist with latexsym or amssymb.
+
+%  2005.01.20   PCA     0.9     Rename class file to sigplanconf.cls.
+
+%  2005.03.05   PCA     0.91    Change default copyright data.
+
+%  2005.03.06   PCA     0.92    Add at-signs to some macro names.
+
+%  2005.03.07   PCA     0.93    The 'onecolumn' option defaults to '11pt',
+%                               and it uses the full type width.
+
+%  2005.03.15   PCA     0.94    Add at-signs to more macro names.
+%                               Allow margin paragraphs during review.
+
+%  2005.03.22   PCA     0.95    Implement \euro.
+%                               Remove proof and newdef environments.
+
+%  2005.05.06   PCA     1.0     Eliminate 'onecolumn' option.
+%                               Change footer to small italic and eliminate
+%                               left portion if no \preprintfooter.
+%                               Eliminate copyright notice if preprint.
+%                               Clean up and shrink copyright box.
+
+%  2005.05.30   PCA     1.1     Add alternate permission statements.
+
+%  2005.06.29   PCA     1.1     Publish final first edition of guide.
+
+%  2005.07.14   PCA     1.2     Add \subparagraph.
+%                               Use block paragraphs in lists, and adjust
+%                               spacing between items and paragraphs.
+
+%  2006.06.22   PCA     1.3     Add 'reprint' option and associated
+%                               commands.
+
+%  2006.08.24   PCA     1.4     Fix bug in \maketitle case command.
+
+%  2007.03.13   PCA     1.5     The title banner only display with the
+%                               'preprint' option.
\ No newline at end of file
diff --git a/doc/thrift.tex b/doc/thrift.tex
new file mode 100644
index 0000000..eb8d939
--- /dev/null
+++ b/doc/thrift.tex
@@ -0,0 +1,857 @@
+%-----------------------------------------------------------------------------
+%
+%               Thrift whitepaper
+%
+% Name:         thrift.tex
+%
+% Authors:      Mark Slee (mcslee@facebook.com)
+%
+% Created:      05 March 2007
+%
+%-----------------------------------------------------------------------------
+
+
+\documentclass[nocopyrightspace,blockstyle]{sigplanconf}
+
+\usepackage{amssymb}
+\usepackage{amsfonts}
+\usepackage{amsmath}
+
+\begin{document}
+
+% \conferenceinfo{WXYZ '05}{date, City.} 
+% \copyrightyear{2007}
+% \copyrightdata{[to be supplied]} 
+
+% \titlebanner{banner above paper title}        % These are ignored unless
+% \preprintfooter{short description of paper}   % 'preprint' option specified.
+
+\title{Thrift: Scalable Cross-Language Services Implementation}
+\subtitle{}
+
+\authorinfo{Mark Slee, Aditya Agarwal and Marc Kwiatkowski}
+           {Facebook, 156 University Ave, Palo Alto, CA}
+           {\{mcslee,aditya,marc\}@facebook.com}
+
+\maketitle
+
+\begin{abstract}
+Thrift is a software library and set of code-generation tools developed at
+Facebook to expedite development and implementation of efficient and scalable
+backend services. Its primary goal is to enable efficient and reliable
+communication across programming languages by abstracting the portions of each
+language that tend to require the most customization into a common library
+that is implemented in each language. Specifically, Thrift allows developers to
+define data types and service interfaces in a single language-neutral file
+and generate all the necessary code to build RPC clients and servers.
+
+This paper details the motivations and design choices we made in Thrift, as
+well as some of the more interesting implementation details. It is not
+intended to be taken as research, but rather it is an exposition on what we did
+and why.
+\end{abstract}
+
+% \category{D.3.3}{Programming Languages}{Language constructs and features}
+
+%\terms
+%Languages, serialization, remote procedure call
+
+%\keywords
+%Data description language, interface definition language, remote procedure call
+
+\section{Introduction}
+As Facebook's traffic and network structure have scaled, the resource
+demands of many operations on the site (i.e. search, 
+ad selection and delivery, event logging) have presented technical requirements
+drastically outside the scope of the LAMP framework. In our implementation of
+these services, various programming languages have been selected to
+optimize for the right combination of performance, ease and speed of
+development, availability of existing libraries, etc. By and large,
+Facebook's engineering culture has tended towards choosing the best
+tools and implementations avaiable over standardizing on any one
+programming language and begrudgingly accepting its inherent limitations.
+
+Given this design choice, we were presented with the challenge of building
+a transparent, high-performance bridge across many programming languages.
+We found that most available solutions were either too limited, did not offer
+sufficient data type freedom, or suffered from subpar performance.
+\footnote{See Appendix A for a discussion of alternative systems.}
+
+The solution that we have implemented combines a language-neutral software
+stack implemented across numerous programming languages and an associated code
+generation engine that transforms a simple interface and data definition
+language into client and server remote procedure call libraries.
+Choosing static code generation over a dynamic system allows us to create
+validated code with implicit guarantees that can be run without the need for
+any advanced intropsecive run-time type checking. It is also designed to
+be as simple as possible for the developer, who can typically define all
+the necessary data structures and interfaces for a complex service in a single
+short file.
+
+Surprised that a robust open solution to these relatively common problems
+did not yet exist, we committed early on to making the Thrift implementation
+open source.
+
+In evaluating the challenges of cross-language interaction in a networked
+environment, some key components were identified:
+
+\textit{Types.} A common type system must exist across programming languages
+without requiring that the application developer use custom Thrift data types
+or write their own serialization code. That is,
+a C++ programmer should be able to transparently exchange a strongly typed
+STL map for a dynamic Python dictionary. Neither
+programmer should be forced to write any code below the application layer
+to achieve this. Section 2 details the Thrift type system. 
+
+\textit{Transport.} Each language must have a common interface to
+bidirectional raw data transport. The specifics of how a given
+transport is implemented should not matter to the service developer.
+The same application code should be able to run against TCP stream sockets,
+raw data in memory, or files on disk. Section 3 details the Thrift Transport
+layer.
+
+\textit{Protocol.} Data types must have some way of using the Transport
+layer to encode and decode themselves. Again, the application
+developer need not be concerned by this layer. Whether the service uses
+an XML or binary protocol is immaterial to the application code.
+All that matters is that the data can be read and written in a consistent,
+deterministic matter. Section 4 details the Thrift Protocol layer.
+
+\textit{Versioning.} For robust services, the involved data types must
+provide a mechanism for versioning themselves. Specifically,
+it should be possible to add or remove fields in an object or alter the
+argument list of a function without any interruption in service (or,
+worse yet, nasty segmentation faults). Section 5 details Thrift's versioning
+system.
+
+\textit{Processors.} Finally, we generate code capable of processing data
+streams to accomplish remote procedure call. Section 6 details the generated
+code and TProcessor paradigm.
+
+Section 7 discusses implementation details, and Section 8 describes
+our conclusions.
+
+\section{Types}
+
+The goal of the Thrift type system is to enable programmers to develop using
+completely natively defined types, no matter what programming language they
+use. By design, the Thrift type system does not introduce any special dynamic
+types or wrapper objects. It also does not require that the developer write
+any code for object serialization or transport. The Thrift IDL file is
+logically a way for developers to annotate their data structures with the
+minimal amount of extra information necessary to tell a code generator
+how to safely transport the objects across languages.
+
+\subsection{Base Types}
+
+The type system rests upon a few base types. In considering which types to
+support, we aimed for clarity and simplicity over abundance, focusing
+on the key types available in all programming languages, ommitting any
+niche types available only in specific languages.
+
+The base types supported by Thrift are:
+\begin{itemize}
+\item \texttt{bool} A boolean value, true or false
+\item \texttt{byte} A signed byte
+\item \texttt{i16} A 16-bit signed integer
+\item \texttt{i32} A 32-bit signed integer
+\item \texttt{i64} A 64-bit signed integer
+\item \texttt{double} A 64-bit floating point number
+\item \texttt{string} An encoding-agnostic text or binary string
+\end{itemize}
+
+Of particular note is the absence of unsigned integer types. Because these
+types have no direct translation to native primitive types in many languages,
+the advantages they afford are lost. Further, there is no way to prevent the
+application developer in a language like Python from assigning a negative value
+to an integer variable, leading to unpredictable behavior. From a design
+standpoint, we observed that unsigned integers were very rarely, if ever, used
+for arithmetic purposes, but in practice were much more often used as keys or
+identifiers. In this case, the sign is irrelevant. Signed integers serve this
+same purpose and can be safely cast to their unsigned counterparts (most
+commonly in C++) when absolutely necessary.
+
+\subsection{Containers}
+
+Thrift containers are strongly typed containers that map to the most commonly
+used containers in common programming languages. They are annotated using
+C++ template (or Java Generics) style. There are three types available:
+\begin{itemize}
+\item \texttt{list<type>} An ordered list of elements. Translates directly into
+an STL vector, Java ArrayList, or native array in scripting languages. May
+contain duplicates.
+\item \texttt{set<type>} An unordered set of unique elements. Translates into
+an STL set, Java HashSet, or native dictionary in PHP/Python/Ruby.
+\item \texttt{map<type1,type2>} A map of strictly unique keys to values
+Translates into an STL map, Java HashMap, PHP associative array,
+or Python/Ruby dictionary.
+\end{itemize}
+
+While defaults are provided, the type mappings are not explicitly fixed. Custom
+code generator directives have been added to substitute custom types in
+destination languages (i.e.
+\texttt{hash\_map}, or Google's sparse hash map can be used in C++). The
+only requirement is that the custom types support all the necessary iteration
+primitives. Container elements may be of any valid Thrift type, including other
+containers or structs.
+
+\subsection{Structs}
+
+A Thrift struct defines a common objects to be used across languages. A struct
+is essentially equivalent to a class in object oriented programming
+languages. A struct has a set of strongly typed fields, each with a unique
+name identifier. The basic syntax for defining a Thrift struct looks very
+similar to a C struct definition. Fields may be annotated with an integer field
+identifier (unique to the scope of that struct) and optional default values.
+Field identifiers will be automatically assigned if omitted, though they are
+strongly encouraged for versioning reasons discussed later.
+
+\begin{verbatim}
+struct Example {
+  1:i32 number=10,
+  2:i64 bigNumber,
+  3:double decimals,
+  4:string name="thrifty"
+}\end{verbatim}
+
+In the target language, each definition generates a type with two methods,
+\texttt{read} and \texttt{write}, which perform serialization and transport
+of the objects using a Thrift TProtocol object.
+
+\subsection{Exceptions}
+
+Exceptions are syntactically and functionally equivalent to structs except
+that they are declared using the \texttt{exception} keyword instead of the
+\texttt{struct} keyword.
+
+The generated objects inherit from an exception base class as appropriate
+in each target programming language, the goal being to offer seamless
+integration with native exception handling for the developer in any given
+language. Again, the design emphasis is on making the code familiar to the
+application developer.
+
+\subsection{Services}
+
+Services are defined using Thrift types. Definition of a service is
+semantically equivalent to defining a pure virtual interface in object oriented
+programming. The Thrift compiler generates fully functional client and
+server stubs that implement the interface. Services are defined as follows:
+
+\begin{verbatim}
+service <name> {
+  <returntype> <name>(<arguments>)
+    [throws (<exceptions>)]
+  ...
+}\end{verbatim}
+
+An example:
+
+\begin{verbatim}
+service StringCache {
+  void set(1:i32 key, 2:string value),
+  string get(1:i32 key) throws (1:KeyNotFound knf),
+  void delete(1:i32 key) 
+}
+\end{verbatim}
+
+Note that \texttt{void} is a valid type for a function return, in addition to
+all other defined Thrift types. Additionally, an \texttt{async} modifier
+keyword may be added to a void function, which will generate code that does
+not wait for a response from the server. Note that a pure \texttt{void}
+function will return a response to the client which guarantees that the
+operation has completed on the server side. With \texttt{async} method calls
+the client can only be guaranteed that the request succeeded at the
+transport layer. (In many transport scenarios this is inherently unreliable
+due to the Byzantine Generals' Problem. Therefore, application developers
+should take care only to use the async optimization in cases where dopped
+method calls are acceptable or the transport is known to be reliable.)
+
+Also of note is the fact that argument and exception lists to functions are
+implemented as Thrift structs. They are identical in both notation and
+behavior.
+
+\section{Transport}
+
+The transport layer is used by the generated code to facilitate data transfer.
+
+\subsection{Interface}
+
+A key design choice in the implementation of Thrift was to abstract the
+transport layer from the code generation layer. Though Thrift is typically
+used on top of the TCP/IP stack with streaming sockets as the base layer of
+communication, there was no compelling reason to build that constraint into 
+the system. The performance tradeoff incurred by an abstracted I/O layer
+(roughly one virtual method lookup / function call per operation) was
+immaterial compared to the cost of actual I/O operations (typically invoking
+system calls).
+
+Fundamentally, generated Thrift code just needs to know how to read and
+write data. Where the data is going is irrelevant, it may be a socket, a
+segment of shared memory, or a file on the local disk. The Thrift transport
+interface supports the following methods.
+
+\begin{itemize}
+\item \texttt{open()} Opens the tranpsort
+\item \texttt{close()} Closes the tranport
+\item \texttt{isOpen()} Whether the transport is open
+\item \texttt{read()} Reads from the transport
+\item \texttt{write()} Writes to the transport
+\item \texttt{flush()} Force any pending writes
+\end{itemize}
+
+There are a few additional methods not documented here which are used to aid
+in batching reads and optionally signaling completion of reading or writing
+chunks of data by the generated code.
+
+In addition to the above
+\texttt{TTransport} interface, there is a \texttt{TServerTransport} interface
+used to accept or create primitive transport objects. Its interface is as
+follows:
+
+\begin{itemize}
+\item \texttt{open()} Opens the tranpsort
+\item \texttt{listen()} Begins listening for connections
+\item \texttt{accept()} Returns a new client transport
+\item \texttt{close()} Closes the transport
+
+\end{itemize}
+
+\subsection{Implementation}
+
+The transport interface is designed for simple implementation in any
+programming language. New transport mechanisms can be easily defined as needed
+by application developers.
+
+\subsubsection{TSocket}
+
+The \texttt{TSocket} class is implemented across all target languages. It
+provides a common, simple interface to a TCP/IP stream socket.
+
+\subsubsection{TFileTransport}
+
+The \texttt{TFileTransport} is an abstraction of an on-disk file to a data
+stream. It allows Thrift data structures to be used as historical log data.
+Essentially, an application developer can use a \texttt{TFileTransport} to
+write out a set of
+requests to a file on disk. Later, this data may be replayed from the log,
+either for post-processing or for recreation and simulation of previous events.
+
+\subsubsection{Utilities}
+
+The Transport interface is designed to support easy extension using common
+OOP techniques such as composition. Some simple utilites include the
+\texttt{TBufferedTransport}, which buffers writes and reads on an underlying
+transport, the \texttt{TFramedTransport}, which transmits data with frame
+size headers for chunking optimzation or nonblocking operation, and the
+\texttt{TMemoryBuffer}, which allows reading and writing directly from heap or
+stack memory owned by the process.
+
+\section{Protocol}
+
+A second major abstraction in Thrift is the separation of data structure from
+transport representation. Thrift enforces a certain messaging structure when
+transporting data, but it is agnostic to the protocol encoding in use. That is,
+it does not matter whether data is encoded in XML, human-readable ASCII, or a
+dense binary format, so long as the data supports a fixed set of operations
+that allow generated code to deterministically read and write.
+
+\subsection{Interface}
+
+The Thrift Protocol interface is very straightforward. It fundamentally
+supports two things: 1) bidirectional sequenced messaging, and
+2) encoding of base types, containers, and structs.
+
+\begin{verbatim}
+writeMessageBegin(name, type, seq)
+writeMessageEnd()
+writeStructBegin(name)
+writeStructEnd()
+writeFieldBegin(name, type, id)
+writeFieldEnd()
+writeFieldStop()
+writeMapBegin(ktype, vtype, size)
+writeMapEnd()
+writeListBegin(etype, size)
+writeListEnd()
+writeSetBegin(etype, size)
+writeSetEnd()
+writeBool(bool)
+writeByte(byte)
+writeI16(i16)
+writeI32(i32)
+writeI64(i64)
+writeDouble(double)
+writeString(string)
+
+name, type, seq = readMessageBegin()
+                  readMessageEnd()
+name =            readStructBegin()
+                  readStructEnd()
+name, type, id =  readFieldBegin()
+                  readFieldEnd()
+k, v, size =      readMapBegin()
+                  readMapEnd()
+etype, size =     readListBegin()
+                  readListEnd()
+etype, size =     readSetBegin()
+                  readSetEnd()
+bool =            readBool()
+byte =            readByte()
+i16 =             readI16()
+i32 =             readI32()
+i64 =             readI64()
+double =          readDouble()
+string =          readString()
+\end{verbatim}
+
+Note that every write function has exactly one read function counterpart, with
+the exception of the \texttt{writeFieldStop()} method. This is a special method
+that signals the end of a struct. The procedure for reading a struct is to
+\texttt{readFieldBegin()} until the stop field is encountered, and to then
+\texttt{readStructEnd()}.  The
+generated code relies upon this structure to ensure that everything written by
+a protocol encoder can be read by a matching protocol decoder. Further note
+that this set of functions is by design more robust than necessary.
+For example, \texttt{writeStructEnd()} is not strictly necessary, as the end of
+a struct may be implied by the stop field. This method is a convenience for
+verbose protocols where it is cleaner to separate these calls (i.e. a closing
+\texttt{</struct>} tag in XML).
+
+\subsection{Structure}
+
+Thrift structures are designed to support encoding into a streaming
+protocol. That is, the implementation should never need to frame or compute the
+entire data length of a structure prior to encoding it. This is critical to
+performance in many scenarios. Consider a long list of relatively large
+strings. If the protocol interface required reading or writing a list as an
+atomic operation, then the implementation would require a linear pass over the
+entire list before encoding any data. However, if the list can be written
+as iteration is performed, the corresponding read may begin in parallel,
+theoretically offering an end-to-end speedup of $kN - C$, where $N$ is the size
+of the list, $k$ the cost factor associated with serializing a single
+element, and $C$ is fixed offset for the delay between data being written
+and becoming available to read.
+
+Similarly, structs do not encode their data lengths a priori. Instead, they are
+encoded as a sequence of fields, with each field having a type specifier and a
+unique field identifier. Note that the inclusion of type specifiers enables
+the protocol to be safely parsed and decoded without any generated code
+or access to the original IDL file. Structs are terminated by a field header
+with a special \texttt{STOP} type. Because all the basic types can be read
+deterministically, all structs (including those with nested structs) can be
+read deterministically. The Thrift protocol is self-delimiting without any
+framing and regardless of the encoding format.
+
+In situations where streaming is unnecessary or framing is advantageous, it
+can be very simply added into the transport layer, using the
+\texttt{TFramedTransport} abstraction.
+
+\subsection{Implementation}
+
+Facebook has implemented and deployed a space-efficient binary protocol which
+is used by most backend services. Essentially, it writes all data
+in a flat binary format. Integer types are converted to network byte order,
+strings are prepended with their byte length, and all message and field headers
+are written using the primitive integer serialization constructs. String names
+for fields are omitted - when using generated code, field identifiers are
+sufficient.
+
+We decided against some extreme storage optimizations (i.e. packing
+small integers into ASCII or using a 7-bit continuation format) for the sake
+of simplicity and clarity in the code. These alterations can easily be made
+if and when we encounter a performance critical use case that demands them.
+
+\section{Versioning}
+
+Thrift is robust in the face of versioning and data definition changes. This
+is critical to enable a staged rollout of changes to deployed services. The
+system must be able to support reading of old data from logfiles, as well as
+requests from out of date clients to new servers, or vice versa.
+
+\subsection{Field Identifiers}
+
+Versioning in Thrift is implemented via field identifiers. The field header
+for every member of a struct in Thrift is encoded with a unique field
+identifier. The combination of this field identifier and its type specifier
+is used to uniquely identify the field. The Thrift definition language
+supports automatic assignment of field identifiers, but it is good
+programming practice to always explicitly specify field identifiers.
+Identifiers are specified as follows:
+
+\begin{verbatim}
+struct Example {
+  1:i32 number=10,
+  2:i64 bigNumber,
+  3:double decimals,
+  4:string name="thrifty"
+}\end{verbatim}
+
+To avoid conflicts, fields with omitted identifiers are automatically assigned
+decrementing from -1, and the language only supports the manual assignment of
+positive identifiers.
+
+When data is being deserialized, the generated code can use these identifiers
+to properly identify the field and determine whether it aligns with a field in
+its definition file. If a field identifier is not recognized, the generated
+code can use the type specifier to skip the unknown field without any error.
+Again, this is possible due to the fact that all data types are self
+delimiting.
+
+Field identifiers can (and should) also be specified in function argument
+lists. In fact, argument lists are not only represented as structs on the
+backend, but actually share the same code in the compiler frontend. This
+allows for version-safe modification of method parameters
+
+\begin{verbatim}
+service StringCache {
+  void set(1:i32 key, 2:string value),
+  string get(1:i32 key) throws (1:KeyNotFound knf),
+  void delete(1:i32 key) 
+}
+\end{verbatim}
+
+The syntax for specifying field identifiers was chosen to echo their structure.
+Structs can be thought of as a dictionary where the identifiers are keys, and
+the values are strongly typed, named fields.
+
+Field identifiers internally use the \texttt{i16} Thrift type. Note, however,
+that the \texttt{TProtocol} abstraction may encode identifiers in any format.
+
+\subsection{Isset}
+
+When an unexpected field is encountered, it can be safely ignored and
+discarded. When an expected field is not found, there must be some way to
+signal to the developer that it was not present. This is implemented via an
+inner \texttt{isset} structure inside the defined objects. (In PHP, this is
+implicit with a \texttt{null} value, or \texttt{None} in Python
+and \texttt{nil} in Ruby.) Essentially,
+the inner \texttt{isset} object of each Thrift struct contains a boolean value
+for each field which denotes whether or not that field is present in the
+struct. When a reader receives a struct, it should check for a field being set
+before operating directly on it.
+
+\begin{verbatim}
+class Example {
+ public:
+  Example() :
+    number(10),
+    bigNumber(0),
+    decimals(0),
+    name("thrifty") {} 
+
+  int32_t number;
+  int64_t bigNumber;
+  double decimals;
+  std::string name;
+
+  struct __isset {
+    __isset() :
+      number(false),
+      bigNumber(false),
+      decimals(false),
+      name(false) {}
+    bool number;
+    bool bigNumber;
+    bool decimals;
+    bool name;
+  } __isset;
+...
+}
+\end{verbatim} 
+
+\subsection{Case Analysis}
+
+There are four cases in which version mismatches may occur.
+
+\begin{enumerate}
+\item \textit{Added field, old client, new server.} In this case, the old
+client does not send the new field. The new server recognizes that the field
+is not set, and implements default behavior for out of date requests.
+\item \textit{Removed field, old client, new server.} In this case, the old
+client sends the removed field. The new server simply ignores it.
+\item \textit{Added field, new client, old server.} The new client sends a
+field that the old server does not recognize. The old server simply ignores
+it and processes as normal.
+\item \textit{Removed field, new client, old server.} This is the most
+dangerous case, as the old server is unlikely to have suitable default
+behavior implemented for the missing field. It is recommended that in this
+situation the new server be rolled out prior to the new clients.
+\end{enumerate}
+
+\subsection{Protocol/Transport Versioning}
+The \texttt{TProtocol} abstractions are also designed to give protocol
+implementations the freedom to version themselves in whatever manner they
+see fit. Specifically, any protocol implementation is free to send whatever
+it likes in the \texttt{writeMessageBegin()} call. It is entirely up to the
+implementor how to handle versioning at the protocol level. The key point is
+that protocol encoding changes are safely isolated from interface definition
+version changes.
+
+Note that the exact same is true of the \texttt{TTransport} interface. For
+example, if we wished to add some new checksumming or error detection to the
+\texttt{TFileTransport}, we could simply add a version header into the
+data it writes to the file in such a way that it would still accept old
+logfiles without the given header.
+
+\section{RPC Implementation}
+
+\subsection{TProcessor}
+
+The last core interface in the Thrift design is the \texttt{TProcessor},
+perhaps the most simple of the constructs. The interface is as follows:
+
+\begin{verbatim}
+interface TProcessor {
+  bool process(TProtocol in, TProtocol out)
+    throws TException
+}
+\end{verbatim}
+
+The key design idea here is that the complex systems we build can fundamentally
+be broken down into agents or services that operate on inputs and outputs. In
+most cases, there is actually just one input and output (an RPC client) that
+needs handling.
+
+\subsection{Generated Code}
+
+When a service is defined, we generate a
+\texttt{TProcessor} instance capable of handling RPC requests to that service,
+using a few helpers. The fundamental structure (illustrated in pseudo-C++) is
+as follows:
+
+\begin{verbatim}
+Service.thrift
+ => Service.cpp
+     interface ServiceIf
+     class ServiceClient : virtual ServiceIf
+       TProtocol in
+       TProtocol out
+     class ServiceProcessor : TProcessor
+       ServiceIf handler
+
+ServiceHandler.cpp
+ class ServiceHandler : virtual ServiceIf
+
+TServer.cpp
+ TServer(TProcessor processor,
+         TServerTransport transport,
+         TTransportFactory tfactory,
+         TProtocolFactory pfactory)
+ serve()
+\end{verbatim}
+
+From the thrift definition file, we generate the virtual service interface.
+A client class is generated, which implements the interface and
+uses two \texttt{TProtocol} instances to perform the I/O operations. The
+generated processor implements the \texttt{TProcessor} interface. The generated
+code has all the logic to handle RPC invocations via the \texttt{process()}
+call, and takes as a parameter an instance of the service interface,
+implemented by the application developer.
+
+The user provides an implementation of the application interface in their own,
+non-generated source file.
+
+\subsection{TServer}
+
+Finally, the Thrift core libraries provide a \texttt{TServer} abstraction.
+The \texttt{TServer} object generally works as follows.
+
+\begin{itemize}
+\item Use the \texttt{TServerTransport} to get a \texttt{TTransport}
+\item Use the \texttt{TTransportFactory} to optionally convert the primitive
+transport into a suitable application transport (typically the
+\texttt{TBufferedTransportFactory} is used here)
+\item Use the \texttt{TProtocolFactory} to create an input and output protocol
+for the \texttt{TTransport}
+\item Invoke the \texttt{process()} method of the \texttt{TProcessor} object
+\end{itemize}
+
+The layers are appropriately separated such that the server code needs to know
+nothing about any of the transports, encodings, or applications in play. The
+server encapsulates the logic around connection handling, threading, etc.
+while the processor deals with RPC. The only code written by the application
+developer lives in the definitional thrift file and the interface
+implementation.
+
+Facebook has deployed multiple \texttt{TServer} implementations, including
+the single-threaded \texttt{TSimpleServer}, thread-per-connection
+\texttt{TThreadedServer}, and thread-pooling \texttt{TThreadPoolServer}.
+
+The \texttt{TProcessor} interface is very general by design. There is no
+requirement that a \texttt{TServer} take a generated \texttt{TProcessor}
+object. Thrift allows the application developer to easily write any type of
+server that operates on \texttt{TProtocol} objects (for instance, a server
+could simply stream a certain type of object without any actual RPC method
+invocation).
+
+\section{Implementation Details}
+\subsection{Target Languages}
+Thrift currently supports five target languages: C++, Java, Python, Ruby, and
+PHP. At Facebook, we have deployed servers predominantly in C++, Java, and
+Python. Thrift services implemented in PHP have also been embedded into the
+Apache web server, providing transparent backend access to many of our
+frontend constructs using a \texttt{THttpClient} implementation of the
+\texttt{TTransport} interface.
+
+Though Thrift was explicitly designed to be much more efficient and robust
+than typical web technologies, as we were designing our XML-based REST web
+services API we noticed that Thrift could be easily used to define our
+service interface. Though we do not currently employ SOAP envelopes (in the
+author's opinion there is already far too much repetetive enterprise Java
+software to do that sort of thing), we were able to quickly extend Thrift to
+generate XML Schema Definition files for our service, as well as a framework
+for versioning different implementations of our web service. Though public
+web services are admittedly tangential to Thrift's core use case and design,
+Thrift facilitated rapid iteration and affords us the ability to quickly
+migrate our entire XML-based web service onto a higher performance system
+should the future need arise.
+
+\subsection{Generated Structs}
+We made a conscious decision to make our generated structs as transparent as
+possible. All fields are publicly accessible; there are no \texttt{set()} and
+\texttt{get()} methods. Similarly, use of the \texttt{isset} object is not
+enforced. We do not include any \texttt{FieldNotSetException} construct.
+Developers have the option to use these fields to write more robust code, but
+the system is robust to the developer ignoring the \texttt{isset} construct
+entirely and will provide suitable default behavior in all cases.
+
+The reason for this choice was for ease of application development. Our stated
+goal is not to make developers learn a rich new library in their language of
+choice, but rather to generate code that allow them to work with the constructs
+that are most familiar in each language.
+
+We also made the \texttt{read()} and \texttt{write()} methods of the generated
+objects public members so that the objects can be used outside of the context
+of RPC clients and servers. Thrift is a useful tool simply for generating
+objects that are easily serializable across programming languages.
+
+\subsection{RPC Method Identification}
+Method calls in RPC are implemented by sending the method name as a string. One
+issue with this approach is that longer method names require more bandwidth.
+We experimented with using fixed-size hashes to identify methods, but in the
+end concluded that the savings were not worth the headaches incurred. Reliably
+dealing with conflicts across versions of an interface definition file is
+impossible without a meta-storage system (i.e. to generate non-conflicting
+hashes for the current version of a file, we would have to know about all
+conflicts that ever existed in any previous version of the file).
+
+We wanted to avoid too many unnecessary string comparisons upon
+method invocation. To deal with this, we generate maps from strings to function
+pointers, so that invocation is effectively accomplished via a constant-time
+hash lookup in the common case. This requires the use of a couple interesting
+code constructs. Because Java does not have function pointers, process
+functions are all private member classes implementing a common interface.
+
+\begin{verbatim}
+private class ping implements ProcessFunction {
+  public void process(int seqid,
+                      TProtocol iprot,
+                      TProtocol oprot)
+    throws TException
+  { ...}
+}
+
+HashMap<String,ProcessFunction> processMap_ =
+  new HashMap<String,ProcessFunction>();
+\end{verbatim}
+
+In C++, we use a relatively esoteric language construct: member function
+pointers.
+
+\begin{verbatim}
+std::map<std::string,
+  void (ExampleServiceProcessor::*)(int32_t,
+  facebook::thrift::protocol::TProtocol*,
+  facebook::thrift::protocol::TProtocol*)>
+ processMap_;
+\end{verbatim}
+
+Using these techniques, the cost of string processing is minimized, and we
+reap the benefit of being able to easily debug corrupt or misunderstood data by
+looking for string contents.
+
+\subsection{Servers and Multithreading}
+MARC TO WRITE THIS SECTION ON THE C++ concurrency PACKAGE AND
+BASIC TThreadPoolServer PERFORMANCE ETC. (ie. 140K req/second, that kind of
+thing)
+
+\subsection{Nonblocking Operation}
+Though the Thrift transport interfaces map more directly to a blocking I/O
+model, we have implemented a high performance \texttt{TNonBlockingServer}
+in C++ based upon \texttt{libevent} and the \texttt{TFramedTransport}. We
+implemented this by moving all I/O into one tight event loop using a
+state machine. Essentially, the event loop reads framed requests into
+\texttt{TMemoryBuffer} objects. Once entire requests are ready, they are
+dispatched to the \texttt{TProcessor} object which can read directly from
+the data in memory.
+
+\subsection{Compiler}
+The Thrift compiler is implemented in C++ using standard lex/yacc style
+tokenization and parsing. Though it could have been implemented with fewer
+lines of code in another language (i.e. Python/PLY or ocamlyacc), using C++
+forces explicit definition of the language constructs. Strongly typing the
+parse tree elements (debatably) makes the code more approachable for new
+developers.
+
+Code generation is done using two passes. The first pass looks only for
+include files and type definitions. Type definitions are not checked during
+this phase, since they may depend upon include files. All included files
+are sequentially scanned in a first pass. Once the include tree has been
+resolved, a second pass is taken over all files which inserts type definitions
+into the parse tree and raises an error on any undefined types. The program is
+then generated against the parse tree.
+
+Due to inherent complexities and potential for circular dependencies,
+we explicitly disallow forward declaration. Two Thrift structs cannot
+each contain an instance of the other. (Since we do not allow \texttt{null}
+struct instances in the generated C++ code, this would actually be impossible.)
+
+\section{Conclusions}
+Thrift has enabled Facebook to build scalable backend
+services efficiently by enabling engineers to divide and conquer. Application
+developers can focus upon application code without worrying about the
+sockets layer. We avoid duplicated work by writing buffering and I/O logic
+in one place, rather than interspersing it in each application.
+
+Thrift has been employed in a wide variety of applications at Facebook,
+including search, logging, mobile, ads, and platform. We have
+found that the marginal performance cost incurred by an extra layer of
+software abstraction is eclipsed by the gains in developer efficiency and
+systems reliability.
+
+\appendix
+
+\section{Similar Systems}
+The following are software systems similar to Thrift. Each is (very!) briefly
+described:
+
+\begin{itemize}
+\item \textit{SOAP.} XML-based. Designed for web services via HTTP, excessive
+XML parsing overhead.
+\item \textit{CORBA.} Relatively comprehensive, debatably overdesigned and
+heavyweight. Comparably cumbersome software installation.
+\item \textit{COM.} Embraced mainly in Windows client softare. Not an entirely
+open solution.
+\item \textit{Pillar.} Lightweight and high-performance, but missing versioning
+and abstraction.
+\item \textit{Protocol Buffers.} Closed-source, owned by Google. Described in
+Sawzall paper.
+\end{itemize}
+
+\acks
+
+Many thanks for feedback on Thrift (and extreme trial by fire) are due to
+Martin Smith, Karl Voskuil, and Yishan Wong.
+
+Thrift is a successor to Pillar, a similar system developed
+by Adam D'Angelo, first while at Caltech and continued later at Facebook.
+Thrift simply would not have happened without Adam's insights.
+
+%\begin{thebibliography}{}
+
+%\bibitem{smith02}
+%Smith, P. Q. reference text
+
+%\end{thebibliography}
+
+\end{document}