|
Authored by: Anonymous on Friday, January 04 2013 @ 10:34 AM EST |
And also necessary to describe fully the algorithm which one is attempting to
patent.
[ Reply to This | Parent | # ]
|
|
Authored by: Anonymous on Friday, January 04 2013 @ 02:15 PM EST |
Of course, specifying
an algorithm makes it plain that it IS an
algorithm, and not
patentable.
But surely an Algorithm is the full, clear, concise, and exact terms [USPTO] which would allow
any programmer to make the patented "Software" invention, but if, as you say,
algorithms are unpatentable, then software inventions as they require an
algorithm (to describe in full, clear, concise and exact terms how to make them)
must be unpantentable.[ Reply to This | Parent | # ]
|
|
Authored by: Anonymous on Friday, January 04 2013 @ 04:25 PM EST |
And for your amusement:
In one olden-days project i was involved in ('the'
programming language was FORTRAN-77), there was a requirement
that all code had to be presented in pseudo-code before
implementation.
Upon asking what was considered pseudo-code, we where told
that was a complete and unambiguous description of the
functionality of the unit in a format for which no compiler
exists (*).
One part of the project was 'allowed' to be programmed in
'C'. That part was used to implement a script-interpreter.
The gentleman who was in charge of that part managed to get
past the pseudo-code inspection stage by presenting as
pseudo-code a set of slightly-obfuscated (sed...) yacc/lex
input files. He managed to set record time in going from
pseudo-code to a working solution. He also -as turned out-
was the only one whose 'pseudo-code' needed no modifications
upon being implemented.
(*) On a side-note: i did propose to drop the requirement of
'no compiler exists', and next to present FORTRAN-77 source
as pseudo-code; That would have had the advantage that we had
an automatic checker for the completeness and unambiguity:
the FORTRAN-77 compiler... And: yes, after that experience
'we' quickly learned how to use sed to 'hop' between code and
pseudo-code.
One lesson from that experience is still with me today: i
write the (almost..) complete comment for a program first (is
almost pseudo-code, but needs not be complete/unambiguous),
and 'fill in' the statements between the comment lines later.
My point w.r.t. the 'parent' in reference to pseudo-code:
- If you allowing only complete/unambiguous pseudo-code, you
have 'just' re-written your software invention in a badly-
defined and/or unknown programming language, possibly
introducing errors in the process.
- If you'd allow incomplete/ambiguous pseudo-code, you've
swapped fuzzy 'legalese' for fuzzy pseudo-code in a patent
application.
Rather than to allow 'just' source code in a patent
description of a software 'invention' i'd suggest requiring
well-documented (commented..) source code, in a form that can
be compiled using a well-described programming language,
compiler and run-time environment. A bit like what the GPL
requires of sources for re-distribution.
In that form, one 'skilled in the art' can indeed study and
learn from the patent-description of the invention, as is the
stated foundation of the concept of granting a patent.
One problem is that doing so would all too well expose that
the software invention itself is an abstract idea.
A bit off-topic: If progress in field of software is however
counted only in the number of patents granted, then
incomprehensible legalese and binary magic is the way to go.[ Reply to This | Parent | # ]
|
- addendum... - Authored by: Anonymous on Saturday, January 05 2013 @ 12:48 AM EST
- addendum... - Authored by: Anonymous on Sunday, January 06 2013 @ 09:58 AM EST
- Addendum #2 - Helpful twist - Authored by: Anonymous on Sunday, January 06 2013 @ 06:13 AM EST
|
Authored by: celtic_hackr on Friday, January 04 2013 @ 06:37 PM EST |
Source code or pseudo-code should absolutely be required.
It's very simple to describe an idea or algorithm. It's something different
entirely to actually have created an implementation. Just because you have an
idea of something to create, doesn't mean you have the technical skill to
actually implement it. Proof should absolutely be required. Until you've created
a prototype you haven't created anything.[ Reply to This | Parent | # ]
|
|
Authored by: mtew on Saturday, January 05 2013 @ 09:45 AM EST |
The main problem I see with requiring source code is that the result is much
too specific and would require an expert to do the matching. On the other hand
the disclosure requirement has to be implemented somehow.
Does a form
exist that is both explicit enough to express the level of detail required and
fuzzy enough to make the matching process practical?
While I am not
familiar enough with the details to be able to actually provide a definitive
answer, I think this is very similar to the goals of Pattern Definition
Languages.
Comments please. Here or in a new main
topic?
--- MTEW [ Reply to This | Parent | # ]
|
|
Authored by: Anonymous on Saturday, January 05 2013 @ 03:24 PM EST |
The PTO already has a procedure in place that amounts to "show me a
working model" and a standard form for it should you attempt to patent a
perpetual motion machine. Patented software should be no different.
Also, source code, in a reasonably standard language, such as C, is a
lingua franca among those skilled in the art of software, and is certainly
sufficient to particularly and clearly describe the concrete essence of a
piece of software to be patented. Writing it down in supposed English just
obfuscates matters.
Not that I am for software patents... But if they are allowed, the implicit
tradeoff is clearly disclosing the technique in return for exclusivity.
[ Reply to This | Parent | # ]
|
|
|
|
|