#17729: remove the outdated Advocacy HOWTO, as suggested by the author.

1 files changed, 0 insertions, 355 deletions

diff --git a/Doc/howto/advocacy.rst b/Doc/howto/advocacy.rst
deleted file mode 100644
index 2969d26..0000000
--- a/Doc/howto/advocacy.rst
+++ /dev/null
@@ -1,355 +0,0 @@
-*************************
-  Python Advocacy HOWTO
-*************************
-
-:Author: A.M. Kuchling
-:Release: 0.03
-
-
-.. topic:: Abstract
-
-   It's usually difficult to get your management to accept open source software,
-   and Python is no exception to this rule.  This document discusses reasons to use
-   Python, strategies for winning acceptance, facts and arguments you can use, and
-   cases where you *shouldn't* try to use Python.
-
-
-Reasons to Use Python
-=====================
-
-There are several reasons to incorporate a scripting language into your
-development process, and this section will discuss them, and why Python has some
-properties that make it a particularly good choice.
-
-
-Programmability
----------------
-
-Programs are often organized in a modular fashion.  Lower-level operations are
-grouped together, and called by higher-level functions, which may in turn be
-used as basic operations by still further upper levels.
-
-For example, the lowest level might define a very low-level set of functions for
-accessing a hash table.  The next level might use hash tables to store the
-headers of a mail message, mapping a header name like ``Date`` to a value such
-as ``Tue, 13 May 1997 20:00:54 -0400``.  A yet higher level may operate on
-message objects, without knowing or caring that message headers are stored in a
-hash table, and so forth.
-
-Often, the lowest levels do very simple things; they implement a data structure
-such as a binary tree or hash table, or they perform some simple computation,
-such as converting a date string to a number.  The higher levels then contain
-logic connecting these primitive operations.  Using the approach, the primitives
-can be seen as basic building blocks which are then glued together to produce
-the complete product.
-
-Why is this design approach relevant to Python?  Because Python is well suited
-to functioning as such a glue language.  A common approach is to write a Python
-module that implements the lower level operations; for the sake of speed, the
-implementation might be in C, Java, or even Fortran.  Once the primitives are
-available to Python programs, the logic underlying higher level operations is
-written in the form of Python code.  The high-level logic is then more
-understandable, and easier to modify.
-
-John Ousterhout wrote a paper that explains this idea at greater length,
-entitled "Scripting: Higher Level Programming for the 21st Century".  I
-recommend that you read this paper; see the references for the URL.  Ousterhout
-is the inventor of the Tcl language, and therefore argues that Tcl should be
-used for this purpose; he only briefly refers to other languages such as Python,
-Perl, and Lisp/Scheme, but in reality, Ousterhout's argument applies to
-scripting languages in general, since you could equally write extensions for any
-of the languages mentioned above.
-
-
-Prototyping
------------
-
-In *The Mythical Man-Month*, Fredrick Brooks suggests the following rule when
-planning software projects: "Plan to throw one away; you will anyway."  Brooks
-is saying that the first attempt at a software design often turns out to be
-wrong; unless the problem is very simple or you're an extremely good designer,
-you'll find that new requirements and features become apparent once development
-has actually started.  If these new requirements can't be cleanly incorporated
-into the program's structure, you're presented with two unpleasant choices:
-hammer the new features into the program somehow, or scrap everything and write
-a new version of the program, taking the new features into account from the
-beginning.
-
-Python provides you with a good environment for quickly developing an initial
-prototype.  That lets you get the overall program structure and logic right, and
-you can fine-tune small details in the fast development cycle that Python
-provides.  Once you're satisfied with the GUI interface or program output, you
-can translate the Python code into C++, Fortran, Java, or some other compiled
-language.
-
-Prototyping means you have to be careful not to use too many Python features
-that are hard to implement in your other language.  Using ``eval()``, or regular
-expressions, or the :mod:`pickle` module, means that you're going to need C or
-Java libraries for formula evaluation, regular expressions, and serialization,
-for example.  But it's not hard to avoid such tricky code, and in the end the
-translation usually isn't very difficult.  The resulting code can be rapidly
-debugged, because any serious logical errors will have been removed from the
-prototype, leaving only more minor slip-ups in the translation to track down.
-
-This strategy builds on the earlier discussion of programmability. Using Python
-as glue to connect lower-level components has obvious relevance for constructing
-prototype systems.  In this way Python can help you with development, even if
-end users never come in contact with Python code at all.  If the performance of
-the Python version is adequate and corporate politics allow it, you may not need
-to do a translation into C or Java, but it can still be faster to develop a
-prototype and then translate it, instead of attempting to produce the final
-version immediately.
-
-One example of this development strategy is Microsoft Merchant Server. Version
-1.0 was written in pure Python, by a company that subsequently was purchased by
-Microsoft.  Version 2.0 began to translate the code into C++, shipping with some
-C++code and some Python code.  Version 3.0 didn't contain any Python at all; all
-the code had been translated into C++.  Even though the product doesn't contain
-a Python interpreter, the Python language has still served a useful purpose by
-speeding up development.
-
-This is a very common use for Python.  Past conference papers have also
-described this approach for developing high-level numerical algorithms; see
-David M. Beazley and Peter S. Lomdahl's paper "Feeding a Large-scale Physics
-Application to Python" in the references for a good example.  If an algorithm's
-basic operations are things like "Take the inverse of this 4000x4000 matrix",
-and are implemented in some lower-level language, then Python has almost no
-additional performance cost; the extra time required for Python to evaluate an
-expression like ``m.invert()`` is dwarfed by the cost of the actual computation.
-It's particularly good for applications where seemingly endless tweaking is
-required to get things right. GUI interfaces and Web sites are prime examples.
-
-The Python code is also shorter and faster to write (once you're familiar with
-Python), so it's easier to throw it away if you decide your approach was wrong;
-if you'd spent two weeks working on it instead of just two hours, you might
-waste time trying to patch up what you've got out of a natural reluctance to
-admit that those two weeks were wasted.  Truthfully, those two weeks haven't
-been wasted, since you've learnt something about the problem and the technology
-you're using to solve it, but it's human nature to view this as a failure of
-some sort.
-
-
-Simplicity and Ease of Understanding
-------------------------------------
-
-Python is definitely *not* a toy language that's only usable for small tasks.
-The language features are general and powerful enough to enable it to be used
-for many different purposes.  It's useful at the small end, for 10- or 20-line
-scripts, but it also scales up to larger systems that contain thousands of lines
-of code.
-
-However, this expressiveness doesn't come at the cost of an obscure or tricky
-syntax.  While Python has some dark corners that can lead to obscure code, there
-are relatively few such corners, and proper design can isolate their use to only
-a few classes or modules.  It's certainly possible to write confusing code by
-using too many features with too little concern for clarity, but most Python
-code can look a lot like a slightly-formalized version of human-understandable
-pseudocode.
-
-In *The New Hacker's Dictionary*, Eric S. Raymond gives the following definition
-for "compact":
-
-.. epigraph::
-
-   Compact *adj.*  Of a design, describes the valuable property that it can all be
-   apprehended at once in one's head. This generally means the thing created from
-   the design can be used with greater facility and fewer errors than an equivalent
-   tool that is not compact. Compactness does not imply triviality or lack of
-   power; for example, C is compact and FORTRAN is not, but C is more powerful than
-   FORTRAN. Designs become non-compact through accreting features and cruft that
-   don't merge cleanly into the overall design scheme (thus, some fans of Classic C
-   maintain that ANSI C is no longer compact).
-
-   (From http://www.catb.org/~esr/jargon/html/C/compact.html)
-
-In this sense of the word, Python is quite compact, because the language has
-just a few ideas, which are used in lots of places.  Take namespaces, for
-example.  Import a module with ``import math``, and you create a new namespace
-called ``math``.  Classes are also namespaces that share many of the properties
-of modules, and have a few of their own; for example, you can create instances
-of a class. Instances?  They're yet another namespace.  Namespaces are currently
-implemented as Python dictionaries, so they have the same methods as the
-standard dictionary data type: .keys() returns all the keys, and so forth.
-
-This simplicity arises from Python's development history.  The language syntax
-derives from different sources; ABC, a relatively obscure teaching language, is
-one primary influence, and Modula-3 is another.  (For more information about ABC
-and Modula-3, consult their respective Web sites at http://www.cwi.nl/~steven/abc/
-and http://www.m3.org.)  Other features have come from C, Icon,
-Algol-68, and even Perl.  Python hasn't really innovated very much, but instead
-has tried to keep the language small and easy to learn, building on ideas that
-have been tried in other languages and found useful.
-
-Simplicity is a virtue that should not be underestimated.  It lets you learn the
-language more quickly, and then rapidly write code -- code that often works the
-first time you run it.
-
-
-Java Integration
-----------------
-
-If you're working with Java, Jython (http://www.jython.org/) is definitely worth
-your attention.  Jython is a re-implementation of Python in Java that compiles
-Python code into Java bytecodes.  The resulting environment has very tight,
-almost seamless, integration with Java.  It's trivial to access Java classes
-from Python, and you can write Python classes that subclass Java classes.
-Jython can be used for prototyping Java applications in much the same way
-CPython is used, and it can also be used for test suites for Java code, or
-embedded in a Java application to add scripting capabilities.
-
-
-Arguments and Rebuttals
-=======================
-
-Let's say that you've decided upon Python as the best choice for your
-application.  How can you convince your management, or your fellow developers,
-to use Python?  This section lists some common arguments against using Python,
-and provides some possible rebuttals.
-
-**Python is freely available software that doesn't cost anything. How good can
-it be?**
-
-Very good, indeed.  These days Linux and Apache, two other pieces of open source
-software, are becoming more respected as alternatives to commercial software,
-but Python hasn't had all the publicity.
-
-Python has been around for several years, with many users and developers.
-Accordingly, the interpreter has been used by many people, and has gotten most
-of the bugs shaken out of it.  While bugs are still discovered at intervals,
-they're usually either quite obscure (they'd have to be, for no one to have run
-into them before) or they involve interfaces to external libraries.  The
-internals of the language itself are quite stable.
-
-Having the source code should be viewed as making the software available for
-peer review; people can examine the code, suggest (and implement) improvements,
-and track down bugs.  To find out more about the idea of open source code, along
-with arguments and case studies supporting it, go to http://www.opensource.org.
-
-**Who's going to support it?**
-
-Python has a sizable community of developers, and the number is still growing.
-The Internet community surrounding the language is an active one, and is worth
-being considered another one of Python's advantages. Most questions posted to
-the comp.lang.python newsgroup are quickly answered by someone.
-
-Should you need to dig into the source code, you'll find it's clear and
-well-organized, so it's not very difficult to write extensions and track down
-bugs yourself.  If you'd prefer to pay for support, there are companies and
-individuals who offer commercial support for Python.
-
-**Who uses Python for serious work?**
-
-Lots of people; one interesting thing about Python is the surprising diversity
-of applications that it's been used for.  People are using Python to:
-
-* Run Web sites
-
-* Write GUI interfaces
-
-* Control number-crunching code on supercomputers
-
-* Make a commercial application scriptable by embedding the Python interpreter
-  inside it
-
-* Process large XML data sets
-
-* Build test suites for C or Java code
-
-Whatever your application domain is, there's probably someone who's used Python
-for something similar.  Yet, despite being useable for such high-end
-applications, Python's still simple enough to use for little jobs.
-
-See http://wiki.python.org/moin/OrganizationsUsingPython for a list of some of
-the  organizations that use Python.
-
-**What are the restrictions on Python's use?**
-
-They're practically nonexistent.  Consult :ref:`history-and-license` for the full
-language, but it boils down to three conditions:
-
-* You have to leave the copyright notice on the software; if you don't include
-  the source code in a product, you have to put the copyright notice in the
-  supporting documentation.
-
-* Don't claim that the institutions that have developed Python endorse your
-  product in any way.
-
-* If something goes wrong, you can't sue for damages.  Practically all software
-  licenses contain this condition.
-
-Notice that you don't have to provide source code for anything that contains
-Python or is built with it.  Also, the Python interpreter and accompanying
-documentation can be modified and redistributed in any way you like, and you
-don't have to pay anyone any licensing fees at all.
-
-**Why should we use an obscure language like Python instead of well-known
-language X?**
-
-I hope this HOWTO, and the documents listed in the final section, will help
-convince you that Python isn't obscure, and has a healthily growing user base.
-One word of advice: always present Python's positive advantages, instead of
-concentrating on language X's failings.  People want to know why a solution is
-good, rather than why all the other solutions are bad.  So instead of attacking
-a competing solution on various grounds, simply show how Python's virtues can
-help.
-
-
-Useful Resources
-================
-
-http://www.pythonology.com/success
-   The Python Success Stories are a collection of stories from successful users of
-   Python, with the emphasis on business and corporate users.
-
-.. http://www.fsbassociates.com/books/pythonchpt1.htm
-   The first chapter of \emph{Internet Programming with Python} also
-   examines some of the reasons for using Python.  The book is well worth
-   buying, but the publishers have made the first chapter available on
-   the Web.
-
-http://www.tcl.tk/doc/scripting.html
-   John Ousterhout's white paper on scripting is a good argument for the utility of
-   scripting languages, though naturally enough, he emphasizes Tcl, the language he
-   developed.  Most of the arguments would apply to any scripting language.
-
-http://www.python.org/workshops/1997-10/proceedings/beazley.html
-   The authors, David M. Beazley and Peter S. Lomdahl,  describe their use of
-   Python at Los Alamos National Laboratory. It's another good example of how
-   Python can help get real work done. This quotation from the paper has been
-   echoed by many people:
-
-   .. epigraph::
-
-      Originally developed as a large monolithic application for massively parallel
-      processing systems, we have used Python to transform our application into a
-      flexible, highly modular, and extremely powerful system for performing
-      simulation, data analysis, and visualization. In addition, we describe how
-      Python has solved a number of important problems related to the development,
-      debugging, deployment, and maintenance of scientific software.
-
-http://pythonjournal.cognizor.com/pyj1/Everitt-Feit_interview98-V1.html
-   This interview with Andy Feit, discussing Infoseek's use of Python, can be used
-   to show that choosing Python didn't introduce any difficulties into a company's
-   development process, and provided some substantial benefits.
-
-.. http://www.python.org/psa/Commercial.html
-   Robin Friedrich wrote this document on how to support Python's use in
-   commercial projects.
-
-http://www.python.org/workshops/1997-10/proceedings/stein.ps
-   For the 6th Python conference, Greg Stein presented a paper that traced Python's
-   adoption and usage at a startup called eShop, and later at Microsoft.
-
-http://www.opensource.org
-   Management may be doubtful of the reliability and usefulness of software that
-   wasn't written commercially.  This site presents arguments that show how open
-   source software can have considerable advantages over closed-source software.
-
-http://www.faqs.org/docs/Linux-mini/Advocacy.html
-   The Linux Advocacy mini-HOWTO was the inspiration for this document, and is also
-   well worth reading for general suggestions on winning acceptance for a new
-   technology, such as Linux or Python.  In general, you won't make much progress
-   by simply attacking existing systems and complaining about their inadequacies;
-   this often ends up looking like unfocused whining.  It's much better to point
-   out some of the many areas where Python is an improvement over other systems.
-