Debugging—The Nine Indispensable Rules for Finding Even the Most Elusive Software elusive software and hardware problems / David J. Agans. p. cm. Debugging. 9 Indispensable Rules for Finding the Most Elusive Software and. Hardware Problems. David Agans' Debugging. ○ A short book. Lutz Prechelt, [email protected] 2 / Source. • David J. Agans: " Debugging – The 9 indispensable rules for finding even the most elusive software.

Debugging By David Agans Pdf

Language:English, Japanese, French
Published (Last):21.10.2015
ePub File Size:28.51 MB
PDF File Size:17.15 MB
Distribution:Free* [*Registration needed]
Uploaded by: ADELAIDE

Article (PDF Available) in IEEE Software 20(6) · December with Reads Debugging by David J. Agans, AMA-. COM, The Debugging Rules. • reproduce the bug Understanding debugging tools and their limitations: . software and hardware problems” by David J. Agans. DEBUGGING. Understand the system from Debugging © by David Agans . ERROR: Your program has đO. I gy. A * *. SIAR.

There was never enough memory 32K of program space. Then, like now, developers spent an inordinate amount of time optimizing and rewriting code to fit into the limited space. Consider that a tiny 32K program controlled the attitude indicator, all thrusting and guidance, a user interface, and much more.

And what was the user interface? Parts of the UI included windows not on a desktop, but those glass things that were etched with navigational info. The computer prompted the astronaut with angle data; he looked out through the markings and designated new targeting parameters to the computer. Did the computer have an UI Who was driving what?

The pilot was just another component in the system. Mindell paints the moon flights as a background patina to the guidance theme. An entire chapter is devoted to Apollo 11, but other describing how the astronauts used the stars to align the inertial reference platform the author ignores the flight to and from the moon. The chapter covers the landing sequence in detail -- some might say excruciating detail but I was riveted.

Most remember the and alarms that caused great concern.

JavaScript Required

It turns out that Aldrin wanted to leave the rendezvous radar which was only needed to seek out the command module turned on in case an emergency abort was needed.

Program management signed off on this change, but no one told the software engineers. Data from the radar demanded computer attention that was in short supply, so it flashed the and codes indicating "I'm getting overwhelmed! That's pretty slick software engineering. A single chapter covers the descent and landing phases of the next five missions Apollo 13 is left out as it never entered lunar orbit.

CSE 15L David J Agans - Debugging.pdf - Debugging Table of...

Many are familiar with the abort switch failure, later traced to a blob of solder, that could have ended 14's mission. That's described brilliantly, but the software patch is glossed over in a short barrage of words that left me feeling the author really didn't understand the fix. This book is short on deep technical details about the AGC. But it provides a fascinating look at the human side of engineering, and how pilot demands think "customer demands" , both reasonable and not, effect how we build systems.

Those inputs, Mindell thinks, largely shaped the design of the Space Shuttle. He quotes astronaut Walter Cunningham about splashing down in the sea in Apollo: "[the crew were recovered] by helicopter like a bag of cats saved from a watery grave. The book starts with a quick introduction to logic, which emphasizes the electrical, rather than the Boolean, nature of real devices.

A chapter on outputs is equally practical. The authors talk about using buffer chips and transistor circuits to drive relays solid state and otherwise and optoisolators. The chapter on inputs talks about real-world problems like bounce and circuit isolation. You'll learn how to compute the values of pull-ups, LED resistors, and the like. The final chapter on interfacing to sensors walks the reader through using thermal switches, Hall-effect sensors, encoders and more.

What I like most about the book is its mix of hardware and software. Most pages have a bit of code plus a schematic.

All code snippets are in C. This is a great introduction to the tough subject of tying a computer to the real world. It's the sort of quick-start of real value to people with no experience in the field.

White Click picture to order from site. In my opinion, any bit of code that doesn't do BOTH of these things really well is totally unacceptable. Well written comments are the basic structure of any program. The comments describe the intent, the complexities, the tricks and the issues. Code just obfuscates these. Great comments are a basic ingredient of great code. That means the comments have to be well written, in English at least for those of us working in English-speaking countries , using the noun-verb form.

Each sentence starts with an upper-case letter; the rest of the sentence uses appropriate cases. Comments that don't conform to the basic rules of grammar are flawed. Donald Knuth talked about this at length. He felt that the literate programmer: Is concerned with the excellence of style Can be regarded as an essayist With thesaurus in hand, chooses variable names carefully Strives for a comprehensible program Introduces elements in a way that's best for human understanding, not computer compilation.

In a mere pages the authors tell us how to write well. Just five bucks from site.

See a Problem?

Unfortunately, most developers are notoriously bad at writing prose. We NEED the help that this book contains. One rule: 'Use active voice'.

Doesn't that sound better than 'the use of the active voice is required'? It's also shorter and thus easier to write! Another: 'Omit needless words,' a great improvement over 'writers will examine each sentence and identify, characterize, and excise words in excess of those essential to conveying the author's intent.

English is quite a quirky language; it's easy to make really stupid mistakes. One example: mixing up the verb "effect", the noun "effect" and "?

The book makes an interesting comment about signing letters: 'Thanking you in advance. I like that!

My biggest pet peeve about poor writing is mixing up 'your' and 'you're. The book gives 18 simple rules, far fewer than the nuns attempted to beat into my brain so long ago. Follow them and your comments, and thus the code, will improve. Like all of her works, it's clear and complete.

Axelson starts with a brief overview of the basics of networking, with an overview of the datagrams, protocols and required hardware. Technical readers will already be familiar with much of this information, but it's presented in a very readable fashion that's easy to understand.

Much of the book covers serving up Web pages and working with dynamic data on the web. Sure, there's been plenty of coverage in hundreds of books of these subjects, but she presents everything in the context of embedded systems, especially systems with limited resources.

And that's where the real strength of this book lies. Like her previous work, this is a practical, how to use networking in an embedded system book.

I've used the Rabbit parts a lot, and find them powerful and fun to work with. If you're already a networking whiz this book probably won't add much to your knowledge.

Axelson's web site www. It's already filling with lots of useful information about networking that serves as a companion to the book. Check it out! I put 'hard' in quotes as the various Linux vendors continue to slug out the notion of real-time in the Linux environment. When you have a bug in a program, it means that you have a particular belief about how your program should behave, and somewhere in the program this belief is violated.

For example, you may believe that a certain variable should always be 0 when you start a "for" loop, or a particular pointer can never be NULL in a certain "if statement". To check such beliefs, set a breakpoint in the debugger at a line where you can check the validity of your belief.

JavaScript Required

And when your program hits the breakpoint, ask the debugger to display the value of the variable in question. The assert macro is a good way to automatically check beliefs that are easily coded as a boolean expression.

See the Program-Checking Tools notes. Tip 2: Narrow down your search If you have a situation where a variable does not have the value you expect, and you want to find a place where it is modified, instead of walking through the entire program line by line, you can check the value of the variable at several points in the program and narrow down the location of the misbehaving code.

Tip 3: Walk through your code Steve Maguire the author of Writing Solid Code recommends using the debugger to step through every new line of code you write, at least once, in order to understand exactly what your code is doing.

It helps you visually verify that your program is behaving more or less as intended.

With judicious use, the step, next and finish commands can help you trace through complex code quickly and make it possible to examine key data structures as they are built. For example, using GDB inside the emacs editor puts you in a split-window mode, where in one of the windows you run your GDB session, and in the other window the GDB moves an arrow through the lines of your source file as they are executed. To use GDB through emacs do the following: Start emacs. Type the "meta" key followed by an "x".

At the prompt type "gdb". Each of these chapters describes the rule, explains why it's a rule, and includes several "sub-rules" that explain how to apply the rule. Most importantly, there are lots of "war stories" that are both fun to read and good illustrations of how to put the rule into practice. Since the whole book revolves around the nine rules, it might help to understand the book by skimming the rules and their sub-rules: Understand the system: Read the manual, read everything in depth, know the fundamentals, know the road map, understand your tools, and look up the details.

Make it fail: Do it again, start at the beginning, stimulate the failure, don't simulate the failure, find the uncontrolled condition that makes it intermittent, record everything and find the signature of intermittent bugs, don't trust statistics too much, know that "that" can happen, and never throw away a debugging tool. Quit thinking and look get data first, don't just do complicated repairs based on guessing : See the failure, see the details, build instrumentation in, add instrumentation on, don't be afraid to dive in, watch out for Heisenberg, and guess only to focus the search.

Divide and conquer: Narrow the search with successive approximation, get the range, determine which side of the bug you're on, use easy-to-spot test patterns, start with the bad, fix the bugs you know about, and fix the noise first. Change one thing at a time: Isolate the key factor, grab the brass bar with both hands understand what's wrong before fixing , change one test at a time, compare it with a good one, and determine what you changed since the last time it worked.

Keep an audit trail: Write down what you did in what order and what happened as a result, understand that any detail could be the important one, correlate events, understand that audit trails for design are also good for testing, and write it down! Check the plug: Question your assumptions, start at the beginning, and test the tool.

Get a fresh view: Ask for fresh insights just explaining the problem to a mannequin may help! If you didn't fix it, it ain't fixed: Check that it's really fixed, check that it's really your fix that fixed it, know that it never just goes away by itself, fix the cause, and fix the process.

This list by itself looks dry, but the detailed explanations and war stories make the entire book come alive. Many of the war stories jump deeply into technical details; some might find the details overwhelming, but I found that they were excellent in helping the principles come alive in a practical way.

Many war stories were about obsolete technology, but since the principle is the point, that isn't a problem. Not all the war stories are about computing; there's a funny story involving house wiring, for example.

But if you don't know anything about computer hardware and software, you won't be able to follow many of the examples. After detailed explanations of the rules, the rest of the book has a single story showing all the rules in action, a set of "easy exercises for the reader", tips for help desks, and closing remarks.

There are lots of good points here. One that particularly stands out is "quit thinking and look.We added a few bullets. One that particularly stands out is "quit thinking and look. Indeed, in an interview Grace Hopper remarked that she was not coining the term. He has designed and debugged numerous electronic hardware and software systems in his over year engineering career.

If control is just keeping a needle centered on a gauge why stick a heavy human in the control loop?

Was he going to jail? You''ll have a hard time finding many pages that aren''t crammed with directory listings, code, make file extracts, and the arcane argot of those delving deep into Linux.

As a result, the best way to view this book is a collection of things to think about when debugging, rather than a rigorous methodology or procedure. Since the whole book revolves around the nine rules, it might help to understand the book by skimming the rules and their sub-rules: Understand the system: Read the manual, read everything in depth, know the fundamentals, know the road map, understand your tools, and look up the details.

No book's perfect, so here are my gripes and wishes: The sub-rules are really important for understanding the rules, but there's no "master list" in the book or website that shows all the rules and sub-rules on one page.

CLEMENTINA from Hartford
I am fond of exploring ePub and PDF books hungrily. Review my other articles. I have only one hobby: cockfighting.