🚀 go-pugleaf

In article <9209@cactus.org> ritter@cactus.org (Terry Ritter) writes:

   In article <BURLEY.91Sep1202411@churchy.gnu.ai.mit.edu>
   burley@churchy.gnu.ai.mit.edu (Craig Burley) says:

   >  In fact the defense of patents that goes "I believe in protecting
   >intellectual property" really is a defense of the abolishment of all
   >patents.  The patent system serves to RESTRICT intellectual property.

   Nah.  The patent system serves to provide free market ECONOMIC SUPPORT for
   the development and publication of new inventions.  The usefulness of this
   idea may not be apparent if you have been living in the Soviet Union,
   Eastern Europe, or have never had to make research pay for itself.

Both of us are right; the patent system serves to provide incentive by
restricting intellectual property.  I've never denied this, and I support
the patent system in general, as my post made clear, I believe.  But there
is the fact that the patent system is less intended to provide incentive
for development than for publishing the details of an invention -- from what
research I've done, it doesn't seem that patents were intended as a means
to encourage development, just publication.  It was assumed development would
happen either way, which is in fact generally what happens today -- however,
then as now, the danger was seen in having too many important processes kept
secret by their owners and taken to their deathbeds, and in not providing a
way for people to build on top of them by examining how they work.  This
is important in many fields, but has not yet been shown to be needed in the
field of computer software.  I've never heard of anyone discovering a new
approach to something (inventing one) by first reading a software patent and
saying "aha, then if I add <x> to it...Eureka!" and I doubt I ever will.
Even if it happens once or twice, the other side of the coin, the huge cost
involved in turning software creation into 1% development, 40% search for
what is patentable in the development, and 59% search of existing patents
to avoid them far outweighs any occasional positive result from patenting
software (or algorithms, probably the more correct term as someone else
pointed out).

The main difference between computer software and other fields that I know
of is that computer software is the first field in which mechanisms in the
field itself are very likely, if not now, in the near future, to invent
patented or patentable applications on their own.  Since most software
patents (that I know of) are not single "eureka!" ideas but simply
combinations of well-known ideas (XOR with cursor management; avoiding
recomputing expensive functions by saving their temporarily unneeded output
combined with windowing => backing store; keeping numbers in a canonical
byte ordering combined with putting numbers in files designed to port between
machines; and so on), it is becoming increasingly likely that optimizing
compiler technology will be capable of violating/inventing a patent given
a fairly ordinary description of a problem (I already know how to build such
a system, but I can't describe it and must keep it secret until software
patents are abolished; in the meantime, if I manage to build it, at least I
can use it myself and probably make a small fortune off of it).

The result is that, given that you've written a modest-sized application in,
say, C++ or Smalltalk or Eiffel (or any other modern high-level language,
even non-procedural ones, like Prolog, ML, whatever), and compiled it using
the latest global-optimization technology (as of, say, 1995), whose job is
it to check every line of assembly-code output for possible patent violations
and for possible patentable ideas that aren't represented alone in the source
code, but in the source code + the optimizer + the canonical libraries?  That
is a mammoth undertaking even now with our fairly primitive optimizers and
on a reasonably small program.

Right now I know of a personal-computer-based page-layout program whose
internal file format violates a software patent.  Who is responsible for
this violation if the coders simply used one OO library that provided a
means for communicating between different machines' memories in conjunction
with another that provided a means for saving memory contents in disk files,
and they had no idea that canonical byte-ordering was a solution the first
library used (not a patent violation, since the bytes aren't saved to disk
file by the library) and the second library dutifully implemented in a disk
file (not a patent violation to copy arbitrary data to a disk file from
memory)?  But the result is a product that uses canonical byte-ordering
in files designed to be readable on any of several platforms, and thus
violates a patent.  In this case, I suspect the coders didn't use libraries
but wrote the code directly -- but the scenario I illustrate is very likely,
and the coders of the end-user product are capable of having no idea a
patent violation has taken place (implemented by the compiler and linker),
especially when the internals of how the libraries work are hidden from
their view!

My point is that no matter how valuable software patents may SEEM to be, their
implementation is entirely impractical.

   >In case it isn't clear how this is the case, I'll offer an analogy.  You
   >decide to build a house, sit down and design it, order the materials, and
   >build it.  It is your property, of course.  Then one day, a year or so after
   >you've lived in it, somebody comes along and says you have to pay them
   >$50,000 per year to continue living in the house or else destroy it and build
   >another, different house (or at least change it significantly), and even
   >then you still owe them $50K for the first year you lived in it.

   >The reasoning?  They happened to have designed and built a similar house
   >one month before you did, and filed the design with the "Bureau of
   >Housing Property".

   Not quite.  They must have designed a built a house with TOTALLY NEW
   features.  They described the features formally, so that anyone in the
   building field could reproduce them.  They formally argued that each
   feature was new, never before formally described.  A skeptical examiner
   finally allowed some of the claims, after eliminating some, and
   downgrading others.  The full, open description of the inventions became
   available to anyone with $1.50 at the time the patent took effect.

Meanwhile, the ability to continue living in your own house without
rebuilding it is entirely in the hands of someone else who happened to have
the same ideas you had, but spent $$ and time going through a formal, legal
process, while you just built the house?  Why should you be denied use of
your own property?  Remember I do support the idea of patents in general,
which can and do prevent you from, say, selling the plans to your house
even though it's your own design because somebody else patented it first.

   Lets have another analogy:  As a home builder, you decide to benefit
   society by building a totally new kind of house, unlike any ever built
   before.  (We know beforehand that the house will not sell unless SOMEONE
   considers it a specific benefit.)  You invest time, effort, and money
   creating and testing new features, wholly new systems unlike any seen
   before.  Some of these work out, some don't, and some require more
   development.  Eventually, you work them out, and so build a house and
   sell it.  Then you find that any turkey that has access to that house can
   compete with you, even though they spent neither time nor effort in
   development.  Question:  Will you continue to do development?

Answer: Yes, as someone else has pointed out, and it happens all the time.
Similarly, fonts cannot be copyrighted, but we have a plethora of beautiful
ones available to us and more are being designed all the time.  Just as the
computerized instructions for rendering a font are copyrightable, so would
be a text describing how to build a particular design for a house, but in
neither case is the basic idea protected in any way.  The problem with
software/algorithms is that there is no reliable, fair, and relatively
nonintrusive way to separate representation of an idea from its use.

   Do we, as a society, wish to discourage new development?  Would we, as
   a society, prefer that every truly innovative house be sold under a
   non-disclosure agreement?

It's not a problem, and house designs are not patentable.  Thanks for arguing
this line!

   Patents are NOT about AN INDIVIDUAL building something for his or her own
   use.  Although patents do APPLY to individuals, they are almost never
   APPLIED to individuals.  Patents are ECONOMIC tools to recover R&D
   expenses, or to force the rewards to a particular company who did,
   supported, or bought the R&D results.  Patents are about manufacturing,
   sales, and distribution, NOT individual use.

But in the free-software market, individual development IS critical and is
being targeted.  An individual wrote compress; an individual wrote tar;
and so on.  Anyway, patents are NOT economic tools to recover R&D
expenses, or at least not primarily so; patents are tools to encourage
publication of the fruits of R&D expenses.  Please keep this important
difference in mind.  There are far better mechanisms for encouraging R&D
itself -- look at Japan and at various U.S. government programs that do this.
Some of them even insist that the resulting techniques be placed in the
public domain (i.e. not patented or copyrighted) or assigned to the government!

   Patents are also NOT about fairness.  Law itself is not necessarily fair;
   innocent people do get convicted.  But if we are to throw out Law, we
   must accept the results; we accept an imperfect society under law for
   the lack of anything better.  If we throw out patents, we must accept
   that there will be consequences due to the changed economic environment.
   Without patents, many inventions simply will not be applied in practice,
   because there will be no way to prevent a large company from snapping up
   the idea and using their superior resources to dominate the market.
   As an engineer, I have actually heard this argument voiced a number of
   times as a reason to drop a particular line of development.

Innocent people getting convicted is something the law bends over backwards
to avoid in a case where there is a .001% chance that a particular fellow
is not a serial killer and is thereby released on what is commonly called
a technicality.  If we are so willing to avoid unjust conviction in a
heinous case, why do you suggest it is ok for someone to be convicted or
otherwise taken for all the money he or she has simply because they wrote
and distributed compress or X?

And as someone else pointed out, I've never suggested we throw out Law; just
useless, overly interpreted laws that were never intended by our Founding
Fathers in the first place.

   Patents ARE about a deal with society:  a limited-term monopoly in return
   for full public disclosure.  17 years may seem long when you are 20; but you
   will go through 4 or 5 of those periods serially in your life.  It simply
   takes time to develop a market and business around a really new invention.
   Patents are one way that a free market economy encourages expensive
   development.  Alternately, we could have the Government and/or Universities
   do our research and development . . . .

Fine, but with software, I come up with 20 new patentable ideas for every
3 hours of typical programming, based on what the PTO has been awarding as
patents.  That also means I'm potentially violating 20 existing or in-progress
(invisible to me) patents every 3 hours.  That is why I cannot risk releasing
or describing significant software myself while software patents exist, and
I must count on the FSF or some other organization to release software that
I write for me, and take on the risks themselves.  Ultimately, and quite soon,
the existence of software patents will force me and many other individual
contributors (not to mention small companies) out of the field.  I'm quite
prepared for that, because it's quite likely.  Not only can I not afford to
scan all the assembled code I've produced (via compiler, Smalltalk, whatever)
for possible patent violations, but I have no desire to.  If society wants
to slow the rate of software development down approximately five orders of
magnitude, fine, I'll happily flip burgers at MacDonald's, or even more
frightening to anyone who's heard me sing -- go into the music business!

   >Every software patent I've heard of or, so far, can conceive
   >of, is inherently published when its program is published.

   Wrong, wrong, wrong.  In this case, "publication" is a technical term
   under law, and implies FULL OPEN DISCLOSURE of the invention.  The
   vast majority of software is published as OBJECT CODE ONLY; execution
   of that code does NOT disclose anything about how it WORKS, but only what
   it DOES.  What something DOES is NOT a disclosure of HOW TO DO IT.  It is
   this full open disclosure of HOW TO DO IT which is "publication" under
   patent law.  Sure, you might get something out of a disassembly; but this
   is still not FULL OPEN DISCLOSURE.

I have yet to need to look at any of the software patents I've heard about and
yet I've known how they work for years (an exception being LZW compression,
though the source code to compress fixed that problem for me in no time).
On the other hand, I've tried to read the occasional posting of an actual
software patent, and have yet to be able to make head or tails of one, even
when I know what it really means.  I'm not unique in this regard.

With software, unlike other fields, the existence of the program is itself
a description of how to do it.  An executable image is an admittedly more
obscure description than a source listing, but neither are as obscure as
some of the software patents I've read.

If I hand you a bucket of unrefined oil and you hand me gasoline, there's
little I, as an individual, can do to divine your process of converting one
to the other.  Same if I hand you a C program and you hand me the
assembler output, assuming I have no idea what to use the assembler output
for.  But when you hand me an executable image for the compiler and I can
make assembler output out of C programs whenever I want, then it is easy
for me, given a few decent tools, to discover the process.  (Even if you
hand me a refinery for oil to gasoline, discovering the actual process
and understanding why it works is basically impossible for an individual
even given decent tools.)  That is one of the distinguishing characteristics
of software.

   Moreover, one might assume that you think that normal software publication
   (that is, trade secret publication) is better for society than software
   patents.  But the patented sections of software are always fully disclosed,
   may be studied, and may provide insight; some additional work may lead to
   other new, unpatented and useful techniques.

In any instance where it can be shown that a patented-style publication is
more informative and useful and build-upon-able ( :-) than releasing the
source code or even the executable image and using a disassembler, I'll
agree that, in that instance, patentability might well be preferrable.  My
point is that there are so few cases where this will be true compared to the
huge number where it is provably not true, and little likelihood the
continued patentability of software/algorithms will change this, that we
might as well throw out software/algorithm patents and save ourselves the
trouble.  Just as the existence of a few non-software patents that were
themselves published by virtue of the device being sold and the resulting
patent being really unnecessary does not persuade me to throw out the patent
mechanism entirely.

I really get the impression you're not a computer programmer, or at least
not a serious (or efficient) one.  I can hardly keep up with the tiny
percentage of technical journals I actually receive to get new ideas --
and most ideas I read I just ignore, figuring when I need them, I'll
reinvent them anyway most of the time.  Having all the software patents
published to date available at my fingertips, even if I could use them
and publish works based on them for free, would be of extremely little
use to me -- why do I want this when I have to pay for using them?  I get
better ideas for free all the time, from my own inspiration, from reading
journals, from talking to people.  Software patents show no promise to
anyone working in the field that I know of as a means for inspiring further
ideas -- only as a means to secure financial reward for implementing
ideas that are published anyway 99% of the time (and will continue to be,
whatever happens with software patents).  Show me someone who scans software
patents for programming ideas and patents their own code and I'll show you
someone for whom writing one line of code in a week is worthy of celebration.
I've got better things to do, like writing GNU Fortran.  (On the other hand,
if I was doing hardware design, bioengineering, and suchlike, I'd be very
grateful for patents -- you can work for years trying to make just one good
idea workable.  With software it usually takes a few seconds, or as long
as it takes to type in the code and get it to compile, link, and run, so
minimizing the search for the perfect idea is hardly important.)

   In contrast, trade secret publication does not inform anyone except those
   who happen to work in the corporation where it was designed, and any
   inventions in it will die when the software does (and almost ALL software
   eventually dies).  This hardly seems in the interest of society.

If you compare the lifetimes of various popular products in various different
fields, I think you'll find that software dies so fast, it isn't worth
worrying about patents for it.  And, in any case, the whole point is that
it is nearly impossible to succeed at keeping any released software's
internal design secret, unles it is perceived as generally useless and
therefore not worth disassembling.  If I knew less about computers than I
do, and thought indeed important secrets behind a popular program could be
lost forever, I'd agree that patents were important to ensure publication,
but that's not the case.  In fact it amazes me how often totally useless
or rarely sold software programs that attempt to keep their internals
secret via various techniques (zapping debugger registers, copy protection,
et cetera) are nevertheless hacked at by intrepid types who just want to
know how they work -- and effectively published.  This happens with
games and such, and often they're more complex than "real" application
programs!

   >If someone hands me unrefined oil and says "refine it", all
   >the genius in the world won't allow me simply to speak, write, or otherwise
   >communicate refined oil as output.  Similarly, being handed a bunch of
   >chemicals won't allow me to make aspirin, and so on.  Instead, while I must
   >use intellectual processes, I would have to resort to mechanical techniques
   >to accomplish the job.  Thus, it is not a software patent.

   >However, if someone shows me a listing of C code and says "compile it", I
   >might well be able to write down the output of that code as, say, 68K or
   >i486 assembler, and in the process use, in effect, many currently patented
   >techniques, such as IBM's register coloring algorithm, that I may have made
   >up myself.  Note that just because I use a mechanical technique -- pencil on
   >paper -- does not invalidate the premise, because the paper-scratching is
   >NOT the true output of the process, nor is the original listing of C code
   >the true input -- the listing _represents_ the input, as does my output,
   >whether these are in verbal, visual, or other form (braille, for example).

   Translation from one language to another is NOT what software patents are
   about; simply COMPILING patented code is NOT a violation of a patent
   described in that code.  It is the RUNNING of the compiled code, the actual
   action of "refining information," which a patent protects.

I was referring to the compiler itself violating patents; the compiled code
itself is not at issue here in my example.  So my point is that the act of
my brain employing certain algorithms to compile code is itself a patent
violation, in a sense -- or, if not, why should it become one if and when
I reproduce my thought processes in an algorithmic description, which is
what a computer program is?  (If you're going to argue that humans don't
really use algorithms, you're going to have to show how you'll prove that
in a court of law to the satisfaction of everyone -- in other words, you're
going to have to invoke essentially religious arguments in a secular court.
Good luck.)

   Of course, RUNNING "your" compiler code, if parts of it are patented by
   others, COULD be a violation, but, again, patents are NOT ABOUT individual
   use; patents are about manufacturing, sales, and distribution.  In this
   case, patents are about controlling the sales of a compiler which uses a
   patented technique, and all you have to do to be able to sell your compiler
   is to use a different, perhaps better, technique.  Patents thus encourage
   you to improve upon the state of the art.  To the extent that this is
   difficult, you must also acknowledge the importance to society of having
   the technique fully and openly disclosed for the next generation.

Yes, but if my compiler uses a "better" technique that is just an
optimization of a fundamental technique that happens to be patented, i.e.
it is simply a transformation of the patented algorithm to one that is
effectively identical, then either it still violates the patent OR software
patents are useless in fact.  (I.e. instead of XOR cursors, one can
do b := 1-b for every bit in a cursor, which implements XOR using
subtraction -- and how the hardware does that is its own business!)

And as I suggest, I cannot risk publicizing my ideas for much better
optimization and management of software programming because it is very likely
they will violate 100s of trivial patents even if I tried to patent my
five or so significant ones.  Instead I must keep my ideas a personal
secret, hopefully implement them in a useful computer program instead of
just winging it in my own thinking, perhaps even use the resulting program
to achieve personal wealth, and erase the program upon any threat of a
search for patent violation in my own personal system (and instruct it
must be erased along with all related notes when I die, so my estate won't
be at risk for patent violations).  On the other hand, if software
patents are abolished, I can start publishing my ideas right away in whatever
form they need to take at the time.  Perhaps my ideas aren't really all that
great, but are you willing to take that risk?  If you are, then why argue
FOR software patents in the first place?  If not, then here's a case where
software patents clearly PREVENT publication!

   As for the mental process of performing software functions, surely this
   is grasping at straws.  The very fact that programming is difficult is an
   indication of how well our bio-minds follow instructions; the improvement
   is in building machines (and instructions to machines) which ACTUALLY
   follow instructions.

Programming isn't at all difficult.  I've programmed my own mind to do it
quite well.  Again, if I were to write a program that did what I know I already
do in my own mind (and I could do a lot of that right now, I think), I'd
be hit with lots of patent-violation lawsuits.  I become a better programmer
as I use consistent instructions I've learned are useful instead of just
winging it all the time (which still, obviously, has its uses), and I'd like
to publish what I've learned, but I can't take the risk in this society --
software patents basically mean I don't really own my own ways of doing
things.  Note this is not a boast that I've invented all these ideas on my
own!  We all do this to varying extents.  A big reason patents were not to
include "laws of nature" is that it was understood (correctly) to be
impossible to practically determine who truly made the first observations
about anything purely theoretical in sufficient cases to make the patentability
of ideas worthwhile.  We know Einstein discovered e=mc^2 and a few other
cases, but vast portions of mankind's knowledge of theory of all types
came from unidentifiable sources and we have all incorporated this
knowledge in our own thought-patterns in various ways.  Obviously we cannot
be prevented from or taxed on using particular ideas in our own thoughts!
Why should we be when we extend our own thought-processes to computers?

   Moreover, virtually any electronic device which produces information could
   be reduced to Boolean instructions which, in principle, could be performed
   mentally.  This certainly includes computer CPU's themselves.  Are computer
   CPU's NOT patentable hardware because a human could, IN PRINCIPLE (at a
   ten-millionth the speed and an error rate billions of times higher), perform
   "the same" operations?  I think most people would say that a dividing line
   has been crossed here.

Uh, if you can, via thought and abstractable communication alone, scan a
keyboard, drive a display or printer, interpret and generate modem signals,
store magnetic data on floppies, read/write/refresh dynamic RAM, then I
very much would like to meet you in person!!  You could replace a few
expensive workstations I have around here....

The point is that the idea of a clock, an example of a device that produces
information, is not patentable.  However, a particular clock that drives
a particular display is patentable, and rightly so, if the invention meets
the usual requirements.  There is even a design patent that can be
awarded for a design element that is nonfunctional, as in the appearance
of a clock face (say, for example, it uses Exacto knives for hands and is
made by Exacto -- they can get a design patent on that aspect).  But
the transformation of the passage of time into information on what time
it is is entirely algorithmic (if you allow that time itself is of an
algorithmic nature, in that it is a law of nature), and thus not
patentable -- until recently.

   >In summary, we should go back to the 1981-and-earlier standards for
   >patentability, and abolish software patents retroactively.  Processes that
   >include software may still be patented, but use of the software (equations)
   >that is in the patent should not, by itself, ever constitute infringement.
   >(In other words, still permit patenting an overall process that happens
   >to involve a computer and a running, specialized program, but don't
   >prevent anyone else from using the special algorithms in that program when
   >they write their own.

   I doubt that there can ever be a consistent legal definition which would
   separate "software" from "hardware."  "Software" is just the term we use to
   describe the practice of forming the instructions TO BE USED BY HARDWARE.
   Without hardware, software ALREADY does not infringe patents; patents are
   about the USE of software TO PERFORM HARDWARE ACTIONS.  It is these actions
   which are patented.

Then nobody who writes a program violates a patent, it is only those who
actually run the program?  Hardly.  The developer running his/her own program
to test it wouldn't violate by these standards, because one can use a
patented technique for testing purposes and such (I forget the exact
wording, but it means you can experiment with a patented technique without
worry), unless he/she sold the results of those runs.  But leave users holding
the bag for actually running the program to get work done?  Nobody who wants
software patents will agree with you on this one!  And yet this highlights
one of the areas of uncertainty of software patents.  With traditional
guidelines for a patent, it was always sufficiently clear who was doing the
violating -- with matter-transformation processes, somebody has to build and/or
run a machine to transform the matter.  With software, the program exists
even when no machine exists to run it, and the machine ends up being of
virtually no particular consequence.  Other discussions in this newsgroup
have (properly) chastized the idea of implementing patented algorithms in
the source code, commenting them out with the comment "this is patented, so
we can't ship it", then of course the user can uncomment the code and
recompile -- this would be a great idea if patent violation occurred only
when the technique was actually implemented in a running machine.  It'd
be fun watching AT&T scurry around trying to catch people in the midst of
actually USING X -- or, more properly, overlapping windows, causing an
overlapped window to update one way or another, than exposing the entire
window, at which point the full backing-store implementation is finally
executed!  Given that a sales tax has just been instituted on certain media
like cassette tape, DAT, and such, because someone MIGHT use it to pirate
a recording (a tax I wholeheartedly object to -- I'm paying for someone else's
piracy when I buy a tape, and the money goes not to government programs but
to musicians I might not care about at all), I doubt you'll find anyone
lining up behind your concept of what actions are patented -- except perhaps
those of us who might see it as a feasible way of making software patents
effectively useless.

When you look at patents like IBM's register coloring patent, AT&T's
backing store patent, and so on, you are really seeing that only an
algorithm is being patented.  I think the XOR-cursor might be an exception
if it involves the appearance of the cursor as a key element -- but in that
case, only the appearance of a cursor on a display should be eligible for
protection, probably only design protection at that, and as such would
be, in my opinion, clearly too common, obvious, and trivial to qualify.
But the algorithms are patented, and yet the inputs/outputs of any system
employing them need not betray whether they use those algorithms.  On the
other hand, file formats are apparently patented, as in the case of using
a canonical byte-ordering in a file to handle the difference between
big-endian and little-endian machines, and yet clearly this is an
algorithm given a domain that includes two or more machine architectures
and requires no hardware description to support the patent (whether it
uses hardware description is unimportant here).

   Preventing the application of patents to software would imply that anyone
   who wished to get around a patent on (for example) a new chip (hardware)
   could try to reproduce the design in software (i.e., MICROCODE, in a
   fast single-chip processor) and thus avoid the hardware patent.  In this way,
   eliminating software patents must inherently damage protection for hardware
   logic designs (including computer hardware).  Such protection has been a
   basis for the development of the computer industry, and elimination of
   such protection could have extremely serious consequences far beyond you
   not being able to use your favorite technique in your compiler.

Wrong, since all computer hardware innovation up to this point has not
required software patents per se to be protected!  Again, software is not,
by itself, going to be able to drive a display or scan a keyboard; the
chip design that does these things is indeed hardware and thus patentable,
inclusive of any software that is part of the patented process.  But the
software (algorithm) by itself should not be patentable and should be usable
by itself without risking a patent violation.

   I discussed a number of these issues in my article "The Politics of
   Software Patents" in the May-June 1991 issue of Midnight Engineering.

It is amazing to me that you can have written an article for a
publication (admittedly one I've never heard of), presumably done all
the necessary research, and yet state that "[software patents have] been a
basis for the development of the computer industry" -- my understanding
based on only sketchy research and reading these newsgroups (and being
alive a certain number of years) is that software patents as we have been
discussing them have existed no longer than around 10 years, and probably
not (ab)used as software-only patents for that long, yet the computer
industry, up to and including development of microprocessors and such, was
in full swing by 1981.

Anyway, if you are willing to send me a copy of your article, which probably
is more coherent than either of us has been in this forum, I'll send you
my address.  (Or, if you have it online, just email it to me, please!)  I'd
love to read it and see if I can gain any further insight into your
arguments for software patents, either to convince me or to suggest ways
of convincing you to change your position.
--

James Craig Burley, Software Craftsperson    burley@gnu.ai.mit.edu