IBM Patents Optimization 156
jamie(really) writes "IBM appears to want to patent optimizing programs by trial and error, which in the history of programming has, of course, never been done. Certainly, all my optimizations have been the result of good planning. Well done IBM for coming up with this clever idea. What is claimed is: 'A method for developing a computer program product, the method comprising:
evaluating one or more refactoring actions to determine a performance attribute;
associating the performance attribute with a refactoring action used in computer code; and
undoing the refactoring action of the computer code based on the performance attribute.
The method of claim 1 wherein the undoing refactoring is performed when the performance attribute indicates a negative performance effect of the computer code.'"
Let me guess... (Score:5, Interesting)
...there was a $10,000 bonus for patents at IBM in the month of April 2008, right? Alternatively, this was submitted internally at IBM on April 1, and someone missed the joke.
IBMs internal process must have slipped a lot since I was there. I was once on a team which applied for a patent which was useful and arguably non-obvious, the only problem being that IBM had actually done something similar some 20 years before (in a different language)... internal patent people shot it down.
Newton's Method? (Score:3, Interesting)
Isn't the larger class of this idea called Newtons Method? Not only has it been done on the software level; I think the mathematicians may have something to say about it too.
Bad summary, refactoring not optimization (Score:5, Interesting)
This is not a method of gradually figuring out how to boost performance by trying different things.
This invention makes changes to the source code on the fly. The purpose is to allow programmers to re-factor code for readability, but un-do the process before compiling. Presumably this is built in to one of their automatic refactoring applications or IDE. It is about fixing the problems refactoring causes, specifically in this case performance issues. I assume it could work like automatic inlining of small, commonly used functions, but is open to be a lot more complex.
You click the buttons on the GUI, it refactors some things for you and maintains a history of those actions. It stores the resulting code, which you send to source control or final build kit or whatever. When building, it examines which changes had a negative impact on performance and reverts those before compiling.
To the user, the code is refactored. To the computer, it is not.
My question is, how the hell do you debug this kind of output, or store it in source control? You are clearly going to be locked in to the same IDE, and probably same IDE version, and have to check in all of the project files. Cross-compilation is going to be difficult at best, since compiling the raw code won't have the performance enhancements. Clever for a closed-process shop, but kinda impractical.
What will be more interesting is whatever people come up with to deal with the misery this will create.
Re:Worse even than Business Patents (Score:4, Interesting)
Third parties can pay the USPTO a fee (currently $180) to put references into the file of a pending application and have those references considered by the examiner. However, you have to do this within two months of the date of publication (or two months after a notice of allowance in the application, whichever is earlier), and you cannot make any commentary whatsoever concerning the references you cite. You also have to serve the applicant with notice that you filed the references with the USPTO.
See 37 CFR 1.99 and MPEP 1134.01 [uspto.gov] for more details.
Re:Here's an idea: (Score:3, Interesting)
If you're going to comment on a patent, read the patent first.
Actually I'm amazed and delighted that quite possibly for the first time in the history of /. we have a patent story that doesn't mis-identify an application as a grant, and that actually quotes the claims!
Who says there's no such thing as progress?
And the comments have been relatively germane: the patent describes the process of implementing a refactoring, evaluating it (possibly before compilation) and reverting it if it does not pass one or more measures of goodness (time and potentially others.) Everyone who has ever refactored anything has done this.
This is not "debugging by trial and error" but it certainly is "refactoring followed by (possibly pre-compilation) evaluation against some measure of goodness followed by reversion of the refactoring on that basis."
So here's a question: if I create an experimental branch in my local git repository, start a refactoring, decide the cyclomatic complexity of my refactored solution is too high when I get half-way through, and revert by simply dropping the branch without ever committing, would I be violating this patent (if it were granted)? Because I've certainly done that many, many times, as has pretty much everyone else who's ever refactored anything.
Re:lolwut? (Score:3, Interesting)
You're talking about a Supreme Court which ruled that Corporations can spend as much as they want on election campaigns. What the hell makes you think they're going to overturn software and business patents?
The fact that everyone on the Supreme Court unanimously agreed that Bilski is full of crap, for starters. It was essentially a public beating of Bilski's claims.
Click here for analysis of the arguments. [patentlyo.com]
Click here for the full transcript [supremecourtus.gov].