I have been to briefings about source code licensing that specifically call that book out as "do not open".

You could use the algorithms, just not their implementation of the algorithms. If you rewrote it from scratch, following their text (not their source code), you were fully allowed to use it.

I'm curious how this works in the case of reinvention. Some algorithms are so simple that there is basically one canonical way of writing it. I'm assuming copyright doesn't cover the independent implementation in such cases?

Reinvention is ok in term of copyright. Patent would prohibit it.

What would happen if I patented "left pad" in a bunch of languages?

Behold the three pillars of IP protection.

Copyright protects the What (tangible creative works, such as, printed publications, movies, sound recordings, source code, and so on)

Trademark protects the Who (who made this service or product)

Patent protects the How (how does this widget do what is does)

it would be an invalid patent (or at least should be), because 1. There is prior art 2. it is obvious to a domain expert But given the US patent office's track record, I wouldn't be too surprised if you were able to get a patent. Just don't expect it to hold up in court.

But then, if you're patent trolling - does it even need to hold up in court?

IF cost_of_settlement < cost_of_court_action THEN pay_up(); /* ? */

Yep. Until you threaten someone willing to stand up to it, even if it is expensive.

Code cannot be patented - copyright covers that.

Patents on software are not that simple - it needs to describe an entire physical system that gives value to a user, not just an abstract function that does computation.

Your patent would be rejected presumably

The patent would get thrown out on review

Not if you avoid the common names and invent a new name for it. Nowadays they are just doing some searches and patent granted.

Hypothetically, until we get to Google v. Oracle, and now really nobody has any idea what the hell is going on.

I started out a project by copying RK4 verbatim. Over several months it morphed and took on a life of its own as I integrated it into other parts of the program and smoothed out the inefficiencies. At what point does it stop being a derivative work I wonder?

Never. Derivation is not a property which can be "lost". Deriving more things through the process of derivation at not point stops the derivation connection.

You should not include code at any point if you do not have the proper license for it. The copyright pollution spreads and any attempt to "clean room it" would be more expensive than re-writing from scratch.

Did you know that you can't use copyright to protect an algorithm?

But you can copyright the most efficient implementations.

You can only copyright the text of the source code, as if it was literature. Write your own source code to implement the same algorithm using the same efficient techniques, and you're fine (as long as it isn't patented.)

so... rename the variables?

On a more serious note, this:

https://en.wikipedia.org/wiki/Clean_room_design

It depends on the jurisdiction. e.g. Such a thing would not be copyrightable under Australian law. That could be a way around it.

As mentioned above, some algorithms are so simple that there's only one canonical way to write them. (Take 'looping through an array' for example - in each language there's generally one canonical way to do it.) You could argue that the text of that canonical way is copyrightable.

(It's similar to the early days of heat engines, where a guy called James Pickard managed to patent the crank, preventing other engine manufacturers from using cranks and forcing them to use a sun-and-planet gear arrangement instead: https://en.wikipedia.org/wiki/Sun_and_planet_gear )

They protected their code. If I recall correctly you could license it separately.

Nothing stopped you from implementing them yourself.

The implementations are short and simple for easy reading, so they are not the most efficient or practical. Early versions of the code had bugs, so you should not use the old versions of the book.

The key is to do what Steven Muchnick did for his Compiler textbook: Write the algorithms in a made up programming language so no one can run them and find the bugs.

I'm not being facetious, it's called ICAN, and as far as I can tell no compiler exists for it. Other than that it's a great book though, although maybe showing its age in that there isn't much discussion of OOO and ILP etc. And SSA.

Donald Knuth did it first. First with MIX, then with MMIX. http://mmix.cs.hm.edu/

It's a fun reference, but it's very different. It's a CPU rather than a language, he implemented it, and it was designed to be easy to implement.

As I understand it, Lisp was originally expected to be a teaching or proof language with no implementation, then it got implemented.

https://en.wikipedia.org/wiki/Lisp_(programming_language)#Hi...

No, Lisp was developed from 1958 onwards as a list processing language for the IBM 704.

http://jmc.stanford.edu/articles/lisp/lisp.pdf

Page 7:

> The implementation of LISP began in Fall 1958. The original idea was to produce a compiler, but this was considered a major undertaking, and we needed some experimenting in order to get good conventions for subroutine linking, stack handling and erasure. Therefore, we started by hand-compiling various functions into assembly language and writing subroutines to provide a LISP ”environment”.

Amusingly, I had the old "Numerical Recipes" before there were versions for the different languages. Since I was writing in BASIC and then Pascal, I had no hope but to re-write the code myself anyway, and I couldn't afford to update when the new editions came out.

Not too long ago, a colleague asked me if I had a good code for linear regression, and I sent him a copy of the page from my undergraduate data analysis textbook, which had it in FORTRAN IV.

On the other hand I haven't seen red black tree implementation that isn't based on Cormen (in most cases quoted).

I have that book sitting on my bookshelf and would never dream of copying anything verbatim from it. Writing the code out yourself can significantly improve readability of the code.