Customer Reviews

Inventing Software: The Rise of "Computer-Related" Patents

5 star:		(2)
4 star:		(0)
3 star:		(1)
2 star:		(0)
1 star:		(1)

 

 

The book is full of errors and mistakes. The author apparently knows very little about the U.S. patent law. Many assertions of the book are simply wrong. If you want to learn something about patents, this is not the book for you. For example, the author boldly and wrongly declares that the U.S. patent grants 20 years of exclusive use. The author is completely unaware one of the most important terms in intepreting patent claims: "comprising" which means "including but not limited to" in patent law. As a consequence, the author mistakenly, but convincingly, explains in detail why a claim 2 is broader than a claim 1 when in fact the claim 1 is broader than the claim 2. Because the book is well written and easy to read (with interesting statistics and stories, etc.), it is even more dangerous for readers because it constantly declares wrong laws. A reader may be taught some patent myth instead of useful information. The author should have had someone with at least some patent law experience to review it and correct the misstatements before it was released to the public.

Kenneth Nichols is both a computer scientist and a lawyer. This gives him a fantastic grounding from which to write about software patents.

Why should YOU read this book?

Just as a literate programmer reads journal articles, design documents, and source code, so should he or she be able to evaluate software patents. This ability is fast becoming a competitive necessity, for economic as well as legal reasons. (page 55)

What's in this book?

Nichols first explains what the problem is. Why are software patents a problem? How can one enforce a software patent? In what ways does software not fit into the regular patent process? What exactly is a patent anyway?

Software patents are currently defined in terms of algorithms. But what exactly does the court system understand to be an algorithm, and how is that different from the viewpoint of a computer scientist? Answering this question is the subject of chapter two. Along the way, Nichols shows the problems with trying to patent (under the current system) several different programming paradigms such as self-modifying programs and distributed computing, imperative mode versus object-oriented mode versus functional and declarative paradigms. He also shows how software engineering techniques can help document the pieces needed in writing a software patent specification.

Chapter three defines some major terminology of the patent process and shows how it relates to software. For example, there is a distinction between 'novel' and 'nonobvious'. Also, a software patent must carefully delineate the 'scope' and 'claims' of the patent. To help make this book as practical as possible, this chapter examines (in depth), four actual software patents: a text-searching system; an object-oriented database; a 'C' source code blocker; and a special-purpose sorting method.

The next chapter takes on the debate of whether or not software patents are a good idea, and examines each side in detail including the practical concerns of enforcement and detection of infringement. After looking at this debate, Nichols presents the SDKR (named after the lastname initials of its authors: samuelson, Davis, Kapor, and Reichman). The SDKR is a proposal which ``advocates a special form of intellectual property for computer software'' to replace software patents by doing several things:

merge software copyright and software patent; focus on mass market software only;

preserve the software market and still foster software innovation;

create a clear set of legal rules specifically for software;

provide legal protection on a shorter length than current patents, acknowledging that the software lifecycle is very different from other patentable inventions;

provide protection to a program's behavior instead of just the exact implementation that produces a behavior; and

protect ``innovation'' of software instead of the stricter ``inventiveness'' required by current patent law.

Chapter six is chock full of practical advice for software developers who want to protect their software. The next two chapters are a summary and a look at the future of software programming. I highly recommend this book to anyone who plans to develop software as a livelihood... software patents can not only protect your investment of time, energy, and creativity in the programming process, but they can even earn you some extra money if others are forced to license your software from you in order not to violate your patent.

From the first lines of the preface of this work by Kenneth Nichols, it is apparent that what was initially planned to be of more concise scope grew into a discussion of all things associated with software patents, and therein lies the rub. It is interesting that the author notes in just the second sentence that he "came to the conclusion that the particulars of the debate [within the programming community over the desirability and ultimate effect of software patents]...are not that interesting or enlightening". Really? I find it odd that an individual with a J.D. and an M.S. in Computer Science would make such a statement. Of course, his follow-up statement that the "larger and more important story" involves the fact that "software development is a new kind of creative activity, one that defies the neat and mutually exclusive categorizations of intellectual effort as either artistic or scientific" might be true, Frederick P. Brooks wrote extensively on this topic in his classic tome on software engineering long before the USPTO permitted the filing of related patents. Fortunately, Nichols dedicates most of his work to the more boring subject matter, although unfortunately the explanations provided are a bit boring themselves. Putting aside the fact that this book was written in the late 1990s, however, there is a lot to offer here to the professional software engineer as well as the non-technical management community associated with software interests of this nature. For example, the author's concise 20-page introduction introduces well much of the background subject matter. Nichols also discusses well the topics of algorithms, programming, computer science, software engineering, and how patents fit in with this universe. The heart of the text, the third chapter which presents various software patent examples, however, is very poorly constructed in my opinion, although the explanation in its first few pages on major terms such as "novelty" and "nonobviousness" is concisely written. The diagram provided that depicts concepts related to nonobviousness, written in the style of a Venn diagram, is especially well suited for the discussion. The fourth chapter covers the software patent controversy, and the reader is well rewarded in my opinion when reaching this point in the book after 50 pages of rambling. It is strange that the seventh chapter is dedicated to a definition of programming, a discussion best suited for the introductory pages of the book, although some of the quotes provided in these pages are quite entertaining, such as the W. Saba quote from an IEEE periodical that "hardware engineers have gone further than their software counterparts because hardware design became a science...Unlike hardware engineers, software engineers still deal in magic and witchcraft". Interestingly enough, it was just recently that The Economist discussed the emergence of computer science as the foundational branch of science. Last of all, while the sixth chapter boldly begins by proclaiming "we've finally come to the good part" because it deals with recommendations for software developers, only 6 pages are dedicated to the subject! If Nichols is to write further on software patents, I recommend an entire book dedicated to recommendations.

I liked this book because of its practitioner focus. It really explains the law and how it does (and doesn't!) apply to software. Kenneth Nichols also does a good job of "putting things in a universe," helping the reader to understand how the application of patent and copyright law to software has become so muddled.

I especially liked the chapter on "Software Patent Examples" where he discusses the vagaries of applying the law to various typical software products.

The book is also pleasingly short (169 pp.)--fits well in a briefcase as an airline read.

So many books on patent law are written by lawyers who aren't practicing software developers. As a developer and lawyer, Kenneth Nichols is uniquely positioned to comment on this subject. I see that Quorum Books, which I gather is a quality publisher of law titles, agreed.