\tinysection{Reuse and Zipf's Law.}
\ifverbose{
\begin{figure}
\begin{centering}
\includegraphics[scale=0.5]{pyramid}

\caption{\label{f:pyramid}An illustration of where software
abstractions are provided.  The few abstractions needed very
frequently are provided in hardware or by programming languages; the vast 
majority of abstractions are provided by software libraries.}
\end{centering}
\end{figure}
}\ifverbose{
Useful software abstractions are provided in three basic ways:
in hardware, in programming languages, or in libraries.
The level at which abstractions are realized is closely related
to how frequently they are needed.
Integer and floating-point arithmetic are provided in hardware, since 
almost every computer user runs software requiring these.
\ifverbose{  Sine and cosine 
functions are needed in a variety of applications from scientific
computing to gaming, so these are sometimes realized in hardware also.
}
Some common abstractions that don't merit machine instructions are provided
by programming languages: for example, complex numbers and string
manipulation are often provided by languages.
% IA64 includes implementations of sine and cosine in hardware.
Less frequently used abstractions are relegated to software libraries,
and these constitute the bulk of reusable abstractions.  We can think of
abstractions as forming an iceberg, with the tip 
being those abstractions provided in hardware and languages, and the vast
majority lurking in libraries\ifverbose{ (\reffig{f:pyramid})}.
In our view, machine instructions are a special case of ``software components.''
}
\begin{figure}
\begin{centering}
\includegraphics[scale=0.5]{all}

\end{centering}
\caption{\label{f:rates}Data collected from shared objects on
several unix platforms, showing the number of references to library
subroutines.  The observed number of references shows
good agreement with Zipf-style frequency laws of the form $c \cdot n^{-1}$
(dotted diagonal lines).
A detailed explanation of this data is given in \refsec{s:data}.}
\end{figure}
It is known that hardware instruction frequencies follow an
iconic curve described by George K. Zipf for
word use in natural languages \cite{Kuck:1978,Latendresse:IVME:2003,Wortman:1973}.
Zipf noted that if words in a natural language are ranked
according to use frequency, the frequency of the $n^{\mathit{th}}$
word is about $n^{-1}$.  Zipf-style empirical laws crop up in
many fields \cite{Powers:ACL:1998,Li:WWW:2005}.
% Zipf's law can be viewed as
% an extension of a Pareto-style principle 
% that 80\% of the work is accomplished by 20\% of the tools.
Evidence suggests programming language constructs also
follow a Zipf-like law \cite{Berry:SIGPLAN:1983,Laemmel:TR:1977}.  
It is natural then to wonder if
this result might extend to library
components.  Our results support this conclusion.
% http://scholar.google.com/url?sa=U&q=http://pdf.aiaa.org/GetFileGoogle.cfm%3FgID%3D63111%26gTable%3Dmtgpaper
\reffig{f:rates} shows the reuse counts of
subroutines in shared objects on three Unix platforms,
clearly showing Zipf-like $n^{-1}$ curves.
These results are described in detail in \refsec{s:data}.
The appearance of such curves is not happenstance.
In \refsec{s:newderiv} we argue they
are a direct result of programmers trying to write as little
code as possible by reusing library subroutines; this drives
reuse rates toward a ``maximum entropy'' configuration, namely
a Zipf's law curve.
