
EFF wants software patents to include working code - kristianp
http://www.theverge.com/2013/2/15/3992486/eff-wants-software-patents-to-include-working-code
======
lutusp
The problem with the linked article is that "working code" isn't defined. Does
this mean an executable embodiment of the code, or a compilable source? The
difference is obviously very significant.

~~~
eurleif
What if a company programs directly in assembly? Should that make them
ineligible for patents? And if assembly is only allowed when it's the original
language, how would you go about proving that?

What about code that's been compiled, then decompiled back to the original
language? Or just put through an obfuscator?

Basically, I think the nature of code makes it impossible to set up useful
standards.

~~~
lutusp
> What if a company programs directly in assembly? Should that make them
> ineligible for patents?

Not at all. If source code is required, they would simply provide it. I think
the idea is to be as transparent as possible, so any assemblable or compilable
source should qualify.

I should add that I wrote a lot of assembly code years ago -- Apple Writer
(<http://en.wikipedia.org/wiki/Apple_Writer>) was entirely assembly code -- so
I don't think of it as unreadable or even vague.

But this might not be very important -- the intent of requiring "working code"
may only be to prevent software patents that are too broad (and that's
discussed in the article). So this talk about source versus executable may
miss the point.

~~~
eurleif
Sounds like this is a moot point, but I'm still curious: How would you legally
distinguish between programmer-written assembly, and assembly disassembled
from compiled machine code? Without doing that, it's pointless to require
source code, since disassembler-generated assembly is no more useful than the
machine code it was generated from. And it seems like no matter what rules you
set for how the assembly should look, someone could change it just enough to
comply with those rules, while still not being very useful.

~~~
lutusp
> How would you legally distinguish between programmer-written assembly, and
> assembly disassembled from compiled machine code?

The same question could be asked about certain languages that possess this
"de-compilation" property, including Java. And the answer is, if someone
understands the code well enough, (s)he can sprinkle comments and plausible-
sounding function and variable names and pass the result of as the original.

> Without doing that, it's pointless to require source code, since
> disassembler-generated assembly is no more useful than the machine code it
> was generated from.

Yes, to a programmer, but to a lawyer it makes a world of difference. An
invented source code file would have two traits of use as evidence -- it would
be byte-for-byte identical with the real source, but it would have gaps in the
reasoning expressed in the comments, and it might show implausible function
and variable names.

Also, apart from providing a basis for a fraud allegation, requiring a source
file takes more effort than simply providing an executable.

> And it seems like no matter what rules you set for how the assembly should
> look, someone could change it just enough to comply with those rules, while
> still not being very useful.

When all is said and done, I agree. Although such a requirement places
obstacles in the path of cheating, it's not any real barrier to someone who
intends to produce what at first glance seems to be the original source code.

Also, we don't know if this requirement even exists, which was the reason for
my original question. Requiring source might not even be in the minds of those
making this proposal.

------
kristianp
Here is a proposal from an EFF site:
[https://defendinnovation.org/proposal/open-patent-
granting-p...](https://defendinnovation.org/proposal/open-patent-granting-
process) and here is an EFF article from Feb 14 called "Talking Software
Patents with the Patent Office: A Sign of Reform to Come?"

[https://www.eff.org/deeplinks/2013/02/talking-software-
paten...](https://www.eff.org/deeplinks/2013/02/talking-software-patents-
patent-office-sign-reform-come)

------
kristianp
Here is the salient point as theverge sees it. I'm not sure how well it would
work.

"This would help alleviate the problem known as "functional claiming" — this
currently allows patent applicants to submit extremely broad and vague patent
applications that lay claim to all possible approaches to solving a particular
problem rather than a specific solution proposed by the inventor."

------
SlipperySlope
I, for one, applaud the EFF. If we cannot get rid of software patents, then at
least make them easy to improve upon by publishing executable source code.
Improvements to patented things are themselves often worthy patents - thus
fostering innovation.

Yay for the EFF.

