Breakpoints have now been patented

An anonymous reader noted that apparently Breakpoints have now been patented. From the link "A method for debugging including the steps of receiving code having a software breakpoint function therein, running the code for the purpose of debugging, monitoring the code to detect the presence of the software breakpoint function, recognizing the software breakpoint function, determining an action to be performed based on the software breakpoint function, and implementing the action. The present invention also includes an apparatus for implementing the method for debugging and a medium embodying a program of instructions for execution by a device to perform the method for debugging."

Comments

Could someone please patent code comments?

[Anonymous Coward]

I'd love to have this as an excuse for not doing them. Thanks.

Re:Could someone please patent code comments?

[SL Baur]

No that's not what they've patented. They've patented source level debugging with static break points. Apparently the developer litters the source code with SOFTWARE_BREAKPOINT; calls which turn into do-nothing statements if there is no debugger running the code. The target environment appears to be an embedded system like a cellphone.

They have not patented hardware breakpoints, gdb, etc. and a huge advantage of their system is that you could apparently debug and selectively enable/disable breakpoints in a production ROM executable image.

I know noone reads these patents when these kinds of articles go by, this is /., but is it too much to ask that the article submitter or the editor read them first?

Re:Could someone please patent code comments?

[keird]

Visual Basic has had this for years. It's called Stop. When running in the IDE execution breaks at the Stop command just as if you had a breakpoint defined. The command does nothing when running outside of the IDE.

Re:Could someone please patent code comments?

[Almost-Retired]

if that's the case....I think I can find old code that I wrote back in the mid-90's that I did that...

How in 104ee+99 kinds of hell can this patent stand? I was doing that in the late 70's, on an 1802 board called the Cosmac Super Elf, and 6 months later on a pair of z80 boards called the micro-professor. And in both cases I was doing it without an assembler! I was poor, so I looked the hex code up in the manual and entered it with the same hex editor I was using for the debugging, by inserting a breakpoint that took it back to the monitor and captured the machine state for a leasurely inspection. How the hell else did one debug machine code in those days?

Hell and damnation, I'll bet Grace Hopper even used this technique. And I'd bet that same 6-pack she learned it from somebody that had been doing it for 5 years then...

I can't fscking believe this, its only one step more complex than the (in)famous xor patent for moving the curser.

Will someone Please deliver us from the insanity that is our patent system?

--
No Cheers this time, Gene

Next up...

[CdrGlork]

Next to be patented will be the GOTO statement, so ALL YOU LAZY PROGGERS WILL STOP USING IT!

Re:Next up...

[Vihai]

I DO use gotos heavily.

If you know where and how to use them, they actually are a sensible choice.

They are very good in implementing the function rollback code, that is code which has to undo everything the function has done in case of an error.

For example:

int allocstuff(void)
{
        char *a = malloc(100);
        if (!a)
                goto err_malloc_a;

        char *b = malloc(100);
        if (!b)
                goto err_malloc_b;

        return 0;

        free(b);
err_malloc_b:
        free(a);
err_malloc_a:

        return -1;
}

Re:Next up...

[Dachannien]

Your code makes me want to throw up.

Re:Next up...

[gyranthir]

Cobol already exists!!!

Re:Next up...

[Feyr]

he did say human readable

USPTO Link

[MECC]

Here.

Got there from a search at their site...

That's it.

[Manos_Of_Fate]

I'm applying for a patent on "A system of tubes, that carries information globally, so as to assist the procurement of pr0n."

I think this is a bit different

[AKAImBatman]

I'm not up on my patent-ese, but I think this is describing a specific type of breakpoint technology based on virtual functions. Since we've been talking about Javascript so much lately, and it's so easy to do virtual functions in JS, here's an example in JS code:

Debugger.breakPoint = function()
{
//do nothing
};

Now if you put the function in your code, nothing happens:

Debugger.breakPoint();

But if you have the debugger initialized, it will replace the virtual function like this:

Debugger.breakPoint = function()
{
    Debugger.runDebuggerAndStopTheWorld();
};

Thus you end up with software breakpoints that can trigger the debugger based on optional listeners. At least, that's how I understand it. I could be wrong about the actual implementation.

Re:I think this is a bit different

[escay]

From what I understand (read the invention background section in the patent) This is a patent about the implementation of a breakpoint handling mechanism, not the idea of using breakpoints to debug itself. specifically, conventional breakpoint sends a software interrupt that is either caught by (a) the debugger, pausing/halting program execution or (b) the OS, in case no debugger is present, resulting in a system hang or crash. Also the assembly halt code may vary for different processors.

The patented breakpoint function catches interrupts and handles them in a specific way, irrespective of whether a debugger is running or not, and also issues CPU-indepedent halt codes, marking an improvement over existing techniques.

Karma whoring, you say? I just have a fascination for patents.

I have a ton of prior art on this one

[bherman]

Take any of my code....it has a ton of breakpoints. Usually any function with an input breaks at that point.

hardware debugger

[Anonymous Coward]

its a hardware debugger or so it appears, not a software one, they specifically address pitfalls with software debuggers and why they did this method.

while hardware ones arent totally new, they arent that common either. gdb is immune from this for example since its software only.

the abstract isnt the patent, the title isnt the patent, the claims are the patent. Readers are encouraged to read the claims and not spread FUD because they can.

Re:hardware debugger

[richie2000]

I had a hardware breakpoint debugger in The Final Cartridge II on the Commodore 64. That was, what - 20-25 years ago? This patent was issued last year.

That said, the first 13 claims pertain to software only (curio: the word "software" appears no less than 17 times in the first claim, "hardware" scores a big fat zero). Subsequent claims seem to revolve around a device reading a medium where the debug code is stored, ie RAM, some kind of ROM or even a CD with reader would fit this description.
It's so vaguely stated as to be totally useless. Useless, that is, if someone were to actually use this patent to implement something useful. You know, like the patent system was supposed to do. Very useful if it's to be used to threaten competitors and stifle innovation.

"To promote the progress of science and useful arts", my ass.

are you kidding?

[nanosquid]

"Free patents online" is a service that lets you search for patents on-line for free; the patents themselves aren't "free".

Re:How Patents Work

[karolgajewski]

If you look up the application number in the USPTO, you will see that it has indeed matured to patent: US 7,055,140

The enforcability of this patent, however, is left to the discretion of the patent owner.

I just patented CODE WITHOUT COMMENTS

[giafly]

to prevent horrors like OP. Did you notice how the "free(b)" call was after an unconditional return? Somebody didn't.

Re:I think this is a bit different - Not Really

[evought]

Yeah, except that debugging, breakpoints, and "virtual functions" or closures, interpreted code, or whatnot have been around for so long, that there is essentially nothing new under the sun. Smalltalk implementations were able to call into the debugger through an assert-like mechanism. You could then enter the debugger, change values around, and continue execution. Made things much easier when you were in the middle of a multi-day simulation test run and hit a problem. You could note the problem, fix it, and continue. Various Lisp, Scheme, ProLog and so forth variants have done some very neat things with debugging support through assertions, exceptions, traps, and all kinds of mechanisms. Essentially, any time you have an interpretive runtime, people play with different ways to do debugging.

Another way to look at it is that many runtimes will automatically enter the debugger on an exception or trap of some kind. An assertion failure generates an exception or trap. Assertions are generally controlled by DEBUG variables of some kind. Viola! Configurable code-side breakpoints. Different languages handle resumption from exceptions in different ways.

The problem is that people who write patents think that the mere act of putting two things together is innovative, even if the first thing is a tool, and the second is a logical extension of the tool's purpose, like adding "on the Internet" to something and calling it an invention. In this case, they did not even bother to see if it was done before, probably because they have no knowledge of languages outside the mainstream.

Well? Make a point!

[EmbeddedJanitor]

Prior art never seems to be much of an obstacle to getting patents. This keeps the patent industry active, which of course appeals greatly to the patent lawyers.

I recently had a look at the area in which I have one of my patents and found no less than five patents which have claims that mine had. One of them even cited my patent in the search list and still made conflicting claims that were allowed.

This situation is of course ridiculous. There is no accountability in the patent system. That is, there is no feedback in the system that ensures the USPTO provides high quality patents. The USPTO does not get sued if they give out stupid patents. No, you need to hire a patent lawyer and go sort it out in court. There are even some patent lawyers that specialise in mining the patents for prior art conflicts and solicite business that way.

This situation wiill not fix itself because those in the system really like it the way it is. The USPTO keeps cranking out money for Uncle Sam by essentially selling the same property many times over. The lawyers love it. They get to charge fees to apply for a patent, then get to charge even more to fix the mess caused by broken patents. So why would it change?

The only way it will change is if the practitioners become accountable for their actions. If they issue a bad patent then USPTO should pay for fixing the mess. USPTO would not like that, but it would soon improve patent quality. That would reduce patent disputes too, so the lawyers would not like it either.

Step 2?

[fishdan]

Step 1: Patent commenting
Step 2: ???????????
Step 3: Profit!!!!

The problem is there will be no profit because no one comments. On the other hand, at least there is no prior art to rule against your patent.

Re:Step 2?

[sunwukong]

If you really want to make money, patent not commenting code.

Re:What's a breakpoint?

[exp(pi*sqrt(163))]

> How does a developer manage to work for a few years without knowing what a breakpoint is?

His code always worked first time?