Slashdot Mirror
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."
I'd love to have this as an excuse for not doing them. Thanks.
Next to be patented will be the GOTO statement, so ALL YOU LAZY PROGGERS WILL STOP USING IT!
It's good to see that this patent is (or appears to be) registered as a free patent that can be used by anyone.
At the same time it is deeply sad to see that something so obvious and with prior art going back half a century can receive a patent at all. It's just sick.
To Terminate, or not to Terminate, that's the question - SCSIROB
Here.
Got there from a search at their site...
"We are all geniuses when we dream"
- E.M. Cioran
Filing Date: 05/01/2002
Publication Date: 11/06/2003
Now, I'm pretty sure there is a whole slew of prior are on this, especially since it sounds like they are describing the method Visual Studio uses for break points and debugging. Heck even the debugging tools in VB5 and VB6 fit this description and that's from back in the mid/late 90's.
-Rick
"Most people in the U.S. wouldn't know they live in a tyrannical state if it walked up and grabbed their junk." - MyFirs
I'm applying for a patent on "A system of tubes, that carries information globally, so as to assist the procurement of pr0n."
Isn't enough that I ruined a pony, making a gift for you?
At this point, these things aren't really "news" any more, and certainly no longer shocking.
"Thanks for all the money you paid to us. We've used it to buy off ISO among other things" -Microsoft
Seriously America needs to put a stop to software patents, it's damaging your software industry as Knuth puts very well in his letter to the PTO here
Javascript + Nintendo DSi = DSiCade
Take any of my code....it has a ton of breakpoints. Usually any function with an input breaks at that point.
Error: Sig not found.
why not patent the execution of code and debbuging of code on a sheet of paper? hell, somebody please do bomb the Bureau of US patents!
Do not. Touch. Down.
One week into his new job, I suggested he set a breakpoint in his code to quickly determine the cause of a problem. He said: "What's a breakpoint?"
A month later he was fired.
How does a developer manage to work for a few years without knowing what a breakpoint is?
A bad law is an unenforceable law.
Hey people - I read TFA and there's no detail whatsoever attached.
Before y'all get real excited about insane patents:
1) This is a patent application, NOT a granted patent. Hence the serial number beginning 2003 - this means the application was submitted in 2003. It should have been processed now. I'll take a look if I get a spare moment.
2) This is a snippet from the patent abstract, I'd say. It doesn't mean much at all - abstracts are pretty irrelevant to the content of a patent. We have no idea what they are actually patenting from this: it could be an entirely new mechanism for doing this, new code, a genetically engineered cow with the capability of implementing breakpoints.
The abstract means NOTHING - it's often not supposed to. Don't have a cow, guys.
'This writing business. Pencils and what-not. Over-rated if you ask me. Silly stuff. Nothing in it' - Eeyore
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.
Here is the business plan:
1) Patent IDE (Did MS beat me to this?)
2) Patent Breakpoints for finding bugs
3) Patent Bugs
4) Write REALLY bad IDE to force programmers to write buggy code (Oops, guess this step isn't needed)
5) IDE phones home for each bug found using a breakpoint
5) PROFIT TWICE!
Can anyone point to a nice reference concerning the history of breakpoints? I have to imagine that they go back to the beginning of (at least), high-level programming languages.
-m
This little section below seems to summarize what is being patented: The recognition of a call and automatically placing a breakpoint. I use ddd/gdb everyday and I see this being useful when working with a few dynamically linked files...
I just don't think this is innovative enough to be awarded a patent. Does anyone know of any package that already does this?
From the patent in question:
[0038] In this example, instead of placing a special instruction in the place of interest in the source code, a software call to a specially named function is issued. There is no other function of the same name in the code and the debugger always sets a breakpoint at the function of that name. Using an exemplary specially named function, _DebugBreak, what would happen would be the program would execute until it reaches the place where _DebugBreak would be called. The debugger would detect this. The name of the function, _DebugBreak, would be recognized. Then, the exemplary desired action would be to break the execution at the place where _DebugBreak returns. The net result would be that the programs breaks the execution and allows single stepping at exactly the place the programmer intended.
This could be a valid patent if somebody did it in 50's or 60's, though it would have expired by now. How come a technique that has been in use for so long be patented? I cannot but observe that this is incompetence of the highest nature on part of the present day patenting process.
You will never have experience until after you needed it.
I heard it is not legal to patent such things. To patent something that has been used all the time and is a publicly known to everyone in that field, it cannot legally be patented. Of course, the patent office doesn't care they will patent anything just because they will get paid for anything they patent.
"Free patents online" is a service that lets you search for patents on-line for free; the patents themselves aren't "free".
Uh, no. Not worthy of a patent. Maybe at the dawn of programming it was, but there's the concepts of "prior art" and "obvious" that should have easily precluded its being patented in 2007. The fact that this patent passed is scary, and a good indicator that we need to scrap the whole system before some idiot patents "breathing" or "eating" or "using the toilet".
Nothing to see here. Move along.
Shut up, idiot. Oh, and if you were trying to be sarcastic or ironic, don't give up the day-job.
JMP JPM Kriss Kross'll make ya JMP JMP
Is that patent for gotos in code? What about when someone says, "Goto Hell?"
Fight Spammers!
It's not patenting breakpoints, per se that I can determine. It's a software breakpoint put into code pre-compile, and then you can attach a debugger later to take advantage of the hook points put into the code as void functions, but the program can run normally without a debugger attached and not crash the system (which fixes a problem evident from one of the referenced patents (Carter)). Dunno about prior art for this implementation, but breakpoints in general are not claimed in this application.
This is more awesome then the day Awesome McAwesom came to Awesometown!
I am working on a patent on finding and correcting inconsistances, mistakes and unintended results withing the source code of a computer program by use of an application. It is to go with my application for typing source code patent.
In God we trust, all others require data.
In 1989, the lab I worked in had two Intel ICE-85 (In Circuit Emulator) machines, which could debug hardware instructions.
... Summer wasn't so pleasant.
Along with a big IBM boat anchor of a laser printer, our lab was always nice and toasty in the wintertime
Chivalry is not dead, it's just frequently misspelt. - M. Langley
I'll try to patent the use of 'print' statement in debugging.
to prevent horrors like OP. Did you notice how the "free(b)" call was after an unconditional return? Somebody didn't.
Reduce, reuse, cycle
Perhaps we should patent the process of applying for a patent and then sue anyone who tries to patent anything.
Isn't this how at least some FORTH debuggers have worked for decades?
"Encyclopedia" is to "Wikipedia" what "Library" is to "Some people at a bus stop"
I'm in the process of getting "software bugs" patented. No worries- I'm planning on being quite liberal with licensing, just a modest subscription based royalty fee.
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.
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.
Engineering is the art of compromise.
The parent's proposal covers not just if/then, but all conditional jump instructions -- which are used by your compiler to implement if/then, switch, and other conditional flow control.
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.
Nothing great was ever achieved without enthusiasm
Bravo! You deserve both Funny and Insightful for that.
Momentarily, the need for the construction of new light will no longer exist.
Now, let's go before that, to when I used to tool around on a TI 99/4A, using TI Basic. You hit Ctrl-C during your code's execution, and not only do you get a breakpoint, you get "BREAKPOINT AT n" (n being the line number) for the response. This alone was...oh, I want to say 25 years ago, roughly.
So if this went through, somebody's deserving of a nice little LARTing.
This sig no verb.
Maybe the Free Software Foundation should hold the patent. That would create a revenue stream to support the continued development of GNU software.
The abstract is a bit light, but it sounds like the idea of putting break-points inside the source of a file being run through the debugger. I.e. if I'm debugging the code generated from foo.c, then I could insert a breakpoint in the source code, e.g. dbg_break; and have it hook into GDB or something else. If so, either (1) this won't go into GCC or (2) the patent is a bit obvious.
To patent software, it doesn't have to be new, inventive, or even your idea. Thats not the point of a software patent. You just pay a guy to submit anything you tell him to submit, and pay the patent office for the patent. They don't won't even put your idea into google. As long as its not too similar to something in their database, or doesn't violate some law of physics, you are usually good. Its a huge revenue stream for the US. Its the USTPO's opinion that the courts should handle the garbage they let though, and unfortunatly, that translates to the american people subsidizing the patent office by supporting the infrastructure to litigate these patents.
That number is not a patent number. This patent has been applied for and published not not granted yet. As long as it is a year (4-digits) followed by a 7-digit serial number, the patent has not yet been granted.
How is this claim different from this existing patent:
b reakpoints
http://www.google.com/patents?id=EmR4AAAAEBAJ&dq=
Seems someone has beaten them to it...
Read TFA -- The headline of the summary is an outright lie. No patent in evidence. Next story: /. sub makes fool of self, /.editors!
Oh wait, that's not really news.
Obviously I laugh in the face of karma...
Caveat Utilitor
/. , like Wikipedia, needs to work on quality control.
Is there anyone in the patent office? Or is it just a big rubber-stamp machine?
The answer to both questions is "yes."
"Ladies and gentlemen, my killbot features Lotus Notes and a machine gun. It is the finest available."
how can this patent be granted when there is plenty of prior art on the use of breakpoints in debugging? it's in the public domain, and therefore not patentable.
From an admittedly shallow reading of the patent, it seems that it's difference is figuring out what to do on its own. Maybe you're right and that every aspect of what they're trying to do has been done, but I'm not so sure.
In any event, the title of the article ('Breakpoints have now been patented') is demonstrably false. The patent does not claim to patent the basic notion of a breakpoint.
... that the error would be patently obvious to a moderately intelligent Orangutan?
I know I'm supposed to RTFA, but really couldn't the submitter have take the four seconds to type out the name of the patent holder?
"There is more worth loving than we have strength to love." - Brian Jay Stanley
I don't really see this as a surprise, in fact I'm surprised it's still free... If anyone's surprised by this why aren't they surprised that it costs 158 a year just for your right to watch TV in Ireland, 12.70 for each dog you own and 128 to catch fish... Eventually this will just be another needless licence(50 a year to own a compiler and 100 for a debugger, with a 50% communist tax if you use linux)
"they arent that common either"
Yeah, not for you, script kiddie. Those of us developing embedded software use them every day.
A couple rules of thumb concerning the scope of the claims (and enforceability)
1) All issued patent claims are valid and enforceable on what they cover (until otherwise revoked)
2) They don't cover anything previously disclosed
So for instance, all the folks to say "I'm going to patent air" could theoretically get a patent with the independent claim:
1 Air
This would cover all air that was not previously known (since the assumption must be that it is something new). Since air was previously known, the claim covers all air that isn't air. It really could be a nul set, or something so esoteric that no one cares (or heck, maybe it is something new). It isn't vacuum (which would be absence of air). But it won't cover air as we know it.
So sometimes the proper response to a claim isn't to say it's not valid, it's to say "who cares!"
But of course, these are rules of thumb spouted by someone preferring to remain anonymous in case some idiot decides to rely on this as law. Reality has a way of biting thumbs.
I still have the nanosecond length wire she gave out at a conference years ago somewhere in the office. A spectacular woman who is missed.
This application was entered by Epson. The application is also extremely detailed. I am not sure what the point of this "freepatentsonline" web site is, since you can just search the USPTO's web site for free and get the COMPLETE information about a patent or patent application, and not just a summary.
P TO2&Sect2=HITOFF&p=1&u=%2Fnetahtml%2FPTO%2Fsearch- bool.html&r=1&f=G&l=50&co1=AND&d=PG01&s1=200302087 45.PGNR.&OS=DN/20030208745&RS=DN/20030208745
Anyway, here's the link. Methinks this is a non-story. This application seems very specific.
http://appft1.uspto.gov/netacgi/nph-Parser?Sect1=
The T-bit trap in the Program Status Word of the PDP-11 familty of computers...in 1972.
There is no God, and Dirac is his prophet.
DDT debugger running (originally) on the DEC PDP-1 supported breakpoints.
c hnique
http://en.wikipedia.org/wiki/Dynamic_debugging_te
[Insert pithy quote here]
I use a personal methodology where:
- Test harnesses are REQUIRED during development (including at unit-test levels) to determine that the program and the individual modules are all working as intended. (I include test passage in the makefile targeting, so a test failure kills the build. This catches introduced bugs from mods right away.)
- Debuggers are allowed only to diagnose why something is failing.
- Each bit of code has to be correctly covered (not just executed) and its correct behavior verified by a test to be considered "finished". Thus:
- Coding tends to resemble a depth-first tree-walk leaving behind debugged code that is almost never revisited. (Like growing a perfect crystal.)
I find that, while debuggers are occasionally handy, with the "prove it's right" test harness in place there's so much visibility that they are usually more trouble than they're worth. When visibility is insufficient, compiling and linking a module-level mod is so quick that it's usually easier to stick in temporary debugging output statements than fire up a debugger.
By the way: The downside of this methodology is that it's so blazingly fast that it is perceived as slow: I report a finished, debugged component or project in about three times as much time as typical developers report a successful initial (hello-general-outline-world) build or a single debugging iteration. So managers make an apples-and-oranges comparison between my completed projects and others' first-cut efforts and bug-fix cycles. This leads to comments like: "'Rod' took about three times as long as most programmers to come up with a first version - but his first try usually worked." B-(
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
Is anyone else starting to wonder if the Patent Office is using Slashdot to check for prior art, rather than employ clerks to do it in-house?
1. Receive application for patent
2. Create dummy patent-approved page
3. Submit to Slashdot with "Shock! Horror!" summary
(3b. While still claiming expenses for a horde of patent clerks)
4. ????
5. Profit!!!
Watch it CmdrTaco, I'm onto you.
Python coder | PyQt Applications | Writer
"Ladies and gentlemen, my killbot features Lotus Notes and a machine gun. It is the finest available."
Sorry, got bwk and Fred Thompson mixed. B-(
Bantam Dominique roosters crow a four-note song. Once you've heard it as "Happy BIRTHday" you can't NOT hear it that way
Oh,yeah....go ahead and patent something that's been around for....oh.....twenty years or so.
2 cents,
Queen B.
HDGary secures my bank
That MUST be a shallow reading, because AI doesn't exist, and computers can't do that. They can only figure out what to do based on guidance input by a programmer.
"You're right," Fisheye says. "I should have set it on 'whip' or 'chop.'"
dbx (sic) from 4.2 BSD existed with all this functionality on the VAX 11/750 we had running at New Mexico Tech in the late 1980s.
Clearly, this is a bogus patent.
When you run it, it adds a comment at the beginning to tell you what it does. ;'printf($a,39,$a,39);
#!/usr/bin/perl
$a='#!/usr/bin/perl
#this program prints itself, with a prepended comment to explain what it does
$a=%c%s%c;printf($a,39,$a,39)
(IANAL)
{
char *a = ( char * ) malloc( 100 );
if ( !a )
{
return( -1 );
}
char *b = ( char * ) malloc( 100 );
if ( !b )
{
free( a );
return( -1 );
}
return( 0 );
} You do realize it's downright dangerous to write if statements without enclosing braces? For example: .
.
.
if ( a )
b = c;
d = e;
.
.
If you enter the application number in the US PTO search function, you get: http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PT O2&Sect2=HITOFF&p=1&u=%2Fnetahtml%2FPTO%2Fsearch-a dv.htm&r=1&f=G&l=50&d=PALL&S1=20030208745&OS=20030 208745&RS=20030208745
Patent 7,055,140: Software breakpoints implementation via specially named function.
Well, if you really want to make money, patent not doing your job. That way you could probably earn a lot of money on slashdot readers.. :-)
This is first of all:
1). Not a patent, but an application for a patent from 2001.
2). This is a specific implementation of a breakpoint function, not breakpoints in general. The idea of this patent is to use an all purpose void function for doing breakpoints instead of a machine dependent instruction as breakpoints are now done.
Patents have been loose (like the one-click patent), but this isn't one of them. Looking at the date on this patent and the way software is now handled, I believe this patent is a bit dated. Sort of like someone patenting a new way to implement the HTTP over a dialup connection without using SLIP or PPP.
*** Sigs are a stupid waste of bandwidth.
0xCC
We used to have a Bill of Rights. Now, with the rights gone, all we have left is the bill.
From http://portal.uspto.gov/external/portal/pair and searching on the application number 10/136,163, which is US20030208745 (patent application) or US7055140 (Granted patent) it is possible to see the course of a patent application. The application was rejected twice, first on 03-23-2005 as seen under 'image file wrapper' and later at 09-07-2005. However the applicant pointed out that the cited patent (US5835699) does not claim a specific void function. As some has pointed out, USPTO has a backlog of 3 millions patent applications meaning there is not much time to do a proper search for prior art.
That is patentable?
... 1980s!
Strange, I recall using breakpoints with that back in the
SNAFU.
-- Tigger warning: This post may contain tiggers! --
neat, you care for the case where malloc fails, but you get yourself two nice little memory leaks in case malloc suceeds both times.
(this does not apply for those of you working on machines with less than 200bytes of ram)
scnr
> Wouldn't nested 'if..then's be better in this case?
I'd prefer the code as is, using nested ifs for partial cleanup quickly becomes a mess.
I believe goto in general works best when you use it to mimic specific missing language features... In this case "std::auto_ptr" from C++ or "finally" from Java/C#.
Back when I programmed assembler (where use of goto is mandatory), I always put the conceptual high-level construct in a comment, like "if then else endif" or "repeat until".
Heh, I used printf for the longest time, not out of sheer leetness but only because I was to lazy to figure out the debugger. :)
Avoiding GOTOs is often facilitated by alternative designs and the language being used. Languages such as Java and C++ offer try/catch statements, while C requires a GOTO to emulate this functionality. If you delve down to the assembly level, then many operations the don't use GOTOs in the higher-level language are using them when converted to assembly, though in this case they are JMP statements. For example your call to a function at the assembly level would involve pushing some values onto the stack and then jumping to the offset where the subroutine is located.
Jumpstart the tartan drive.
I'd really hope you would not be surprised that a function called "alloc"-something would allocate memory on success.
As sample code leaks since nothing points to the allocated memory, presumably because it is not relevant for the technique being illustrated.
The technique would be useful for a constructor function, returning a pointer to an initialized object. A matching destructor function would then free the memory.
a) You use exceptions at all. Actually, these are worse than goto since you actually jump right out into some random outer dynamic scope.
b) You exit loops early... break, continue, last, again, redo et al.
My feeling is, there's nothing wrong with goto when it is used methodically to implement missing language features or code patterns (like common cleanup). Also it may be used sparingly during code maintenance to modify program behavior without radically reworking code which has already been tested to working state.
-- John.
To be more specific, its a way of debugging an embedded system. This appears to be only part of the debugging system since this would never work without using some specialized hardware. Essentially the patent says this: I put dummy functions on a piece of hardware. A second processor that is somehow monitoring what this processor's doing (there are several ways to do this) reads the executed code, recognizes when a dummy function occurs, then somehow alters code execution on the first processor based on the dummy function's name (or maybe it steals processor control and freezes the first processor somehow). These aren't necessarily breakpoints, but breakpoints can be part of it. The advantage is that the code will function normally if the seperate debugging piece isn't attached. Sounds to me like the software aint that creative, but how they're getting that second processor to modify code execution (and if its even efficient or not) is something that probably deserves a patent. Although, I'm a software guy, not a hardware guy, so maybe thats why the hardware aspect is what sounds special. They really should be patenting the hardware, not this software method, since the hardware is the non-obvious part, and the hardware would imply this kind of usage with the software that uses it. But this is just a patent application, and it has errors in it. It seems to claim more usability than it really should support.
Actually, using exceptions just make the problem worse, as every function call may potentially cause an early exit.
Which is why programming languages with exceptions have mechanisms for automatic cleanups, like finally in Java or std::auto_ptr in C++.
As an aside, why would you want something like this to be configurable?
As I said, many runtimes automatically enter the debugger when a trap of some kind is encountered; I think even gcc does. If the feature is designed to let you see what is going on when the code fails, it should fail whether the code is being debugged or not. If it is designed to let you see what is going on at particular points in the program that are not failures, that is what logging is for. If you want to see what is happening at each such point and step through them, put a break point on the log routine (break Logger.logEntry()). If you want to examine a specific instance, then you know where to put the break point, why change the code?
I have always been fairly heavy handed with assertions and state checking and never once even considered conditionally disabling them. If written with some care, runtime checks have negligible overhead and make considerable difference when diagnosing problems. Of course, I am somewhat biased because a lot of my early experience involved scientific or military applications where either results had to be reproducible or lives depended on them or both. You want a program to fail as early as possible if there is any suspicion it will come up with the wrong answer. This is not to say that you do not attempt to recover where appropriate, just that recovery is by design, not by accident, and that when you do recover, you generally log it somewhere.
Anyway, from looking at the patent, I a) don't see how this is much different from having
in your code and having the debugger kick in at that point (if it is active, or kick you back to the interpreter in some languages), or b) why you would want the code to not fail if the debugger is not active. I know some people have felt strongly about the ability to disable runtime assertions, I have just never understood the point of view.
I suppose it might be nice to be able to have:
but again, it seems at best a minor convenience and it could actually get in the way if that was not what I was intending to look at (like investigating a problem several steps after a successful recovery). It also opens up issues with different programmers on a team assigning breakpoints inconsistently and making it harder for others to debug. Am I missing something?
When I used to program a PDP-8, I would toggle in by hand a halt instruction to stop a misperforming program at a specific location so I could examine the accumulator or memory. Microsoft quickbasic (prewindows) had built in break point and watch capability. Assuming we allow software patents they must be non-obvious, non-trivial, and only of value if they give the user a valuable capability. Things like the Fast Fourier Transform as an example of a valuable algorithm or a spreadsheet, I believe Visicalc was the first, should qualify. Stuff like one-click shopping, no way.
And, if you hide the defines very well beneath a pile of mud, then nobody will ever know that you actually are using gotos.
However, they will know that you use multiple exit points and that is bad design unless you are doing low level kernel and
device driver hacking...
--------
#define try
#define catch(X) X:
#define throw(X) goto X;
void doweirdstuff()
{
try
a = malloc(100);
if ( !a )
{
throw(ABC);
}
b = malloc(100);
if ( !a )
{
throw(DEF);
}
free( b );
free( a );
return XYZ;
catch(ABC)
return XYZ;
catch(DEF)
free( a );
return XYZ;
}
The article linked to the application, not to the patent. The claims are fairly different. Try:
T O2&Sect2=HITOFF&p=1&u=%2Fnetahtml%2FPTO%2Fsearch-b ool.html&r=1&f=G&l=50&co1=AND&d=PTXT&s1=Bystricky. INNM.&OS=IN/Bystricky&RS=IN/Bystricky
http://patft.uspto.gov/netacgi/nph-Parser?Sect1=P
Regardless, another example of an app that should have been reject in whole.
I am a lawyer, but not yours. Anything I tell you might be a total lie intended to benefit my clients at your expense.
Filed in 2002, patent granted in 2003. Hardly a recent occurrence. Too, as soon as someone takes the expense to fight it, it won't stand up. Everything in here has existed for decades.
Thank goodness most programmers write perfect code the first time around, else this could really cause problems.
I would challenge it with LISP implementations (back to the 50's). Except that breakpoints would be done by replacing the eval function for single step, or the function itself for a specific breakpoint. (debug myfunc) and (undebug myfunc), in a nutshell.
Of course, if it EVER got to a Court, all is lost, because trying to explain the implementation of LISP to a jury would be... impossible. Or, for that matter, to most judges.
What is needed is good peer review of patents.
Just another "Cubible(sic) Joe" 2 17 3061
It's not stupid. It's Advanced.
tm
Support TBI Research: http://www.raisinhope.org
The Supreme Court unanimously decided a case the other day, overturning patents for something obvious. I've not read the patent, but it would seem that this fits into the "Obvious" category. That the patented idea might also be a good one, and offer benefits may not justify the patent. I also don't know whether it matters - it will depend upon whether the vendors who compete need this functionality and what the licensing will be. If it gives competitive advantage, but doesn't pay to fight, it will stand. If someone wants to fight, I suspect the patent will fall due to the court decision.
obvious patents are no longer patentable.
The recent Supreme Court ruling about "obviousness" will make this patent worth less than the paper it was printed on. This one will clearly get tossed if they try to enforce it. It is obvious, in the sense that the Court defined the term and prior art exists.
No shit. By 'on its own' I mean dynamically based on the an algorithm that presumably forms the basis for the patent. But thanks for the insight that computers don't think for themselves.
IANAL, but from what I understand there is a reason people don't read patents, at least in the US. If you violate a patent knowingly, you are liable for triple damages, whereas is you violate it unknowingly, only single damages.
Hasn't GDB been doing this for ages? Or is it just me?
"All you need is ignorance and confidence; then success is sure." -- Mark Twain
That is indeed the proper use of gotos (although the example code in question was obviously quickly written and contained a few errors). If you aren't familiar with this, the gotos here are essentially emulating a "finally" clause.
Several responders mentioned "nested ifs"... which is obviously a horrible idea if you think about it for 10 seconds. The nesting gets unreadably deep if you have enough calls that can return error codes (which is quite common).
It is quite annnoying that people who obviously have no real experience with C or programming in general will make blanket statements about never using gotos or other practices... I've found it to be the sort of statement that people who aren't that good at programming make to make themselves sound smarter.
Java and higher level languages tend to not use gotos as much since they have finally clauses. However, if you have *ever* read through any large c code base, you will see tons of goto statements being used to handle errors. Take the linux kernel for example, just run a grep on it or something and you will find tons of gotos.
There's a legal principle called "Sovereign Immunity" which means that the government cannot be sued unless some specific law allows you to. Of course, this is the sort of thing people hire lawyers for--to find some random reason whereby you can sue the government (say, for lack of due process or whatnot).
:-)
Of course, IANAL, so you'll have to hire one if you really want to know; you'd be insane to take anything written on Slashdot as legal advice
Blatant violation of prior art does often get trapped, but you can typically tweak your claims to still get around them.
Engineering is the art of compromise.
This post expresses my opinion, not that of my employer. And yes, IAAL.
Don't worry about that one.
Even software brake points are covered. What do you think gdb remote linked to linux uses when it on hardware without hardware break points.
Their software on mainframe for debugging COBOL does what is described in this patent and more. They have been around for years. Good luck enforcing this one.
Oh, how poetic: CAPTCHA: revenues
Prior art should be a snap on this one. I was debugging with breakpoints 30 years ago.
Someone had to say it....
Hey i have an idea: lets patent a key that will be long and when you press it it will produce no character but will instead displace the cursor. I am rich!!!
>> How does a developer manage to work for a few years without knowing what a breakpoint is?
> His code always worked first time?
Name 3 imaginary things: Santa, the easter bunny and a 10+ line, bug free, first draft program.
Seems a lot like the static methods provided by the Debugger class in .net System.Diagnostics namespace:
i agnostics.debugger_members.aspx
System.Diagnostics.Debugger.Break() - Signals a breakpoint to the attached debugger.
System.Diagnostics.Debugger.IsAttached - bool, obvious
System.Diagnostics.Debugger.Launch() - Pops up the windows start JIT debugging box
System.Diagnostics.Debugger.IsLogging - bool, obvious
System.Diagnostics.Debugger.Log(int level, string category, string message)
http://msdn2.microsoft.com/en-us/library/system.d
3laws: No freebies, no backsies, GTFO.
I thought this functionality had been implemented in Borland's Turbo C/Turbo C++/Turbo Assembler products. I call bogus. It is a shame borland didn't patent this back in the 90's.
In Win32:
if (IsDebuggerPresent())
DebugBreak();
Another thing Microsoft's Visual Studio C runtime library does is called _CRT_DEBUGGER_HOOK, where a debugger can patch a particular void function so that the function will trigger a breakpoint if a debugger is attached.
"Screw Sun, cross-platform will never work. Let's move on and steal the Java language." - Visual J++ Product Manager
Whoops, what will that cost me?
from 09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0
to 45 2F 6E 40 3C DF 10 71 4E 41 DF AA 25 7D 31 3F
All your HD DVDs are belongs to us.
Eclipse PDE and Me
So, I'm going to be charged for every breakpoint I set it my code? Clearly a reason to write more reliable code or step through every single line of my code; thus a reason for better reuse, shorter, efficient code and proper modularity. Would my having used break-points before not count as a prior-art?
No, I don't think that constitutes prior art either. Nothing in the patent deals with interpreters and implicit hook functions.
This isn't an argument I want to win. Software patents are evil. Do keep trying though.
Prior art got tossed out the window when they started letting corporations patent DNA sequences. You think that millions of years of evolution would count for something, but nooooooo.
So software is abstract enough to the laymen at the patent office that it'll be a giveaway goldmine too... Now it's just a matter of time until somebody really gets one for the wheel.
the above is similar to
#ifdef _DEBUG
__asm int 3;
#endif
So this type of code is now patented?
Lots of people have already jumped on you for the above post (a 'dogpile' -- if you've seen a large group of dogs fighting the analogy will be obvious) but let me just jump onto that pile myself and tear off some more skin.
Leaving aside the error in the above code (which was made possible by the use of gotos -- it's easy to misplace a goto label but hard to misplace a } and still have the code compile), consider all the *good* solutions you had to ignore in order to wind up with the above.
You had to ignore exceptions.
You had to ignore "Resource Acquisition Is Initialization".
Maybe, just maybe, there is no C++ compiler for your platform, but there is a C compiler. In that unlikely case, I think I might venture to suggest:
if(a) free(a);
if(b) free(b);
See how that frees those pointers that were allocated, WITHOUT involving a branch that spans the whole function for each one?
Or, if allocation is expensive and you don't want to allocate b if a fails:
a = malloc();
if(a) { b = malloc();
if(b)
} else { free (b);}
} else { free (a);}
This used to be called 'structured programming' back before OO existed.
Of course, that's assuming you can't do it the right way, with OO constructs such as exceptions.
Now, the error-prone and complex way you have chosen to free that memory is less easy to arrive at, IMHO, than many of the good ways of doing it. It also has a twisted elegance which is kind of attractive. I think that this is an example of a bright and competent programmer -- you -- working in an environment where you are under little pressure either to research best practises, or to compare your code to that of others. It's a classic example of how good programming ability is worth very little without the ability to communicate and learn.
Whence? Hence. Whither? Thither.
Why is there no patent #20030208745 at the USPTO? Why does the link go to "free patents online"? Smells bogus.
The Multics system used source level debugging in 1977 when I wa a Multics Analyst. This was a standard feature. I suspect it was part of the original system first booted in 1969.
breakpoints could be inserted by the debugger based on source into the object files. You could add code, branch around code. You could also use tools to trace how many times a line was executed as well as get an estimate of the amount of cpu time spent on each line.
Anyone going bonkers over this needs to look into the rules for submitting material to the patent office in regards to this case to prevent it from ever becoming a patent. That's the point of publishing applications before they are patents. If you know of something out there that would block it, send it in NOW.
If law or patent cannot be understood by a 5 year old, it cannot be passed or granted.
eof
We are Turing O-Machines. The Oracle is out there.
If after training someone how to "do things, the way they are done around here" and if they are still flailing around or if a person gives attitude about adopting the standards and procedures of a workplace, I would consider firing someone.
There are lots of reasons not to use debuggers. In many environments, various kinds of logging or "print" statements is all you have. You may be working with DLL's or ActiveX controls where it was never explained how to trace into them with a debugger (you can even trace mixed C++/Java programs connected through JNI, but you need the right tools and figure out how to use them).
Also, debuggers are not a cure all for many kinds of errors -- they can sometimes place you in the neighborhood of where something goes bad, but it may require a kind of gestalt insight to see what the problem is. Many people regard debuggers as a kind of crutch and discourage their use -- you can go down the road where someone never properly designs their app and devises test cases, and they fall back on the debugger to patch and patch again as problems crop op.
So I hope you meant it as a joke that you fired this person or perhaps that this person was dismissed because they were not performing in some more serious way. I know what people are thinking, he "lied" about qualifications calling himself a programmer when he never set a breakpoint. Give me a break. People can be trained to the methods, processes, standards, and practices of a work place, and if you didn't have time, you could order your employee "we use debuggers and breakpoints around here -- go look up how to do this, report back when you have located your bug."