Re: tr1::function implementation

santiago.anderson@gmail.com wrote:
::
:: I find the reply statement by Pete Becker agreeable:
:: "Copyright covers the expression of an idea. You can use the idea
:: all you
:: like; you cannot copy and publish the author's words (or code),
:: unless
:: there's no other reasonable way to express the idea."

Yes, that's pretty straight forward. You can do things that others
have done before, you can even look at the code to see how it is done,
but you cannot "reuse" the code (unless the copyright holder gives his
permission).

You have to write your own code yourself!

:: So in this moral dilemma, I find myself asking questions such as:
::
:: - Even if I started with the unknown author's code as a reference,

Does "as a reference" mean that you glanced at the code on a web site,
or that you used the actual code as "your" code?

:: can I merely put the LOKI copyright on it because that's what the
:: code has evolved into (the exact same structure minus the
:: typelists)?

No, Loki copyright is for Loki code, not for everythinh that looks
similar.

And even if you put someone else's copyright in you code, you still
need the copyright holder's permission to use it!

:: - What parts of the code are ideas that cannot be expressed in
:: other reasonable ways?

No part of the code is ideas, it is an expression of an idea!

I think Pete meant that if you write your own code, and it happens to
look exactly like someone else'e code, that is ok, IF that is the only
way to express this particular idea.

For example, if you are to display a popup window, the GUI manual says
that you have to call a set of interface functions in a specific
order. If you and I were to do that, our code would certainly call the
same functions in the same order. That would be ok, as it is just
about the only reasonable way to do that.

:: Additionally,
:: all of the "derived-invoker" implementations use a clone function,
:: which is really necessary to implement a copy operation for that
:: design. So is using a clone function further infringment? In
:: other words, can this be reasonably done another way? -

Clone functions has been around a lot longer than tr1. Using old ideas
is ok. Copying code with old ideas, is not!

:: Which of
:: these implementations that I mention in the first posting can be
:: considered similar enough for a claim of copyright infrigement?
:: They all use a similar interface/derived-invoker structure except
:: the Boost implementation. Did all the authors think of this
:: independently, or did some of the authors see another
:: implementation before doing their own? I can honestly say I
:: couldn't come up with the "derived-invoker" mechanism on my own.

You don't have to reinvent the wheel each time you write some code.
Unless there is some nasty patent around, looking at public code or
disussing the ideas with other implementors is quite ok. Happen all
the time.

You are not allowed to COPY the code, but you are allowed to write
something similar on your own. Pete's comment about "no other
reasonable way" comes into play when you actually do write your own
code, but it still turns out to be very similar to someone else's. At
that point, you might have to show that this is the obvious way to do
it.

Bo Persson

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]