How Debuggers Work: Algorithms, Data Structures, and Arch... and over 2 million other books are available for Amazon Kindle . Learn more


or
Sign in to turn on 1-Click ordering.
More Buying Choices
Have one to sell? Sell yours here
Sorry, this item is not available in
Image not available for
Colour:
Image not available

 
Start reading How Debuggers Work on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

How Debuggers Work: Algorithms, Data Structures and Architectures [Paperback]

Jonathan B. Rosenberg
3.0 out of 5 stars  See all reviews (2 customer reviews)
RRP: £36.99
Price: £31.76 & FREE Delivery in the UK. Details
You Save: £5.23 (14%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
In stock.
Dispatched from and sold by Amazon. Gift-wrap available.
Want it Thursday, 23 Oct.? Choose Express delivery at checkout. Details

Formats

Amazon Price New from Used from
Kindle Edition £30.17  
Paperback £31.76  

Book Description

23 Oct 1996 0471149667 978-0471149668
A total guide to debuggers: what they do, how they work, and how to use them to produce better programs "Debuggers are the magnifying glass, the microscope, the logic analyzer, the profiler, and the browser with which a program can be examined."–Jonathan B. Rosenberg Debuggers are an indispensable tool in the development process. In fact, during the course of the average software project, more hours are spent debugging software than in compiling code. Yet, not many programmers really know how to constructively interpret the results they get back from debuggers. And even fewer know what makes these complex suites of algorithms and data structures tick. Now in this extremely accessible guide, Jonathan B. Rosenberg demystifies debuggers for programmers and shows them how to make better use of debuggers in their next projects. Taking a hands–on, problem–solving approach to a complex subject, Rosenberg explains how debuggers work and why programmers use them. Most importantly, he provides practical discussions of debugger algorithms and procedures for their use, accompanied by many practical examples. The author also discusses a wide variety of systems applications, from Microsoft′s Win32 debug API to a large parallel architecture. Visit our Web site at: http://www.wiley.com/compbooks/

Special Offers and Product Promotions

  • Between 20-26 October 2014, spend £10 in a single order on item(s) dispatched from and sold by Amazon.co.uk and receive a £2 promotional code to spend in the Amazon Appstore. Here's how (terms and conditions apply)

Product details

  • Paperback: 272 pages
  • Publisher: John Wiley & Sons (23 Oct 1996)
  • Language: English
  • ISBN-10: 0471149667
  • ISBN-13: 978-0471149668
  • Product Dimensions: 23.6 x 19.2 x 1.7 cm
  • Average Customer Review: 3.0 out of 5 stars  See all reviews (2 customer reviews)
  • Amazon Bestsellers Rank: 1,979,554 in Books (See Top 100 in Books)
  • See Complete Table of Contents

More About the Authors

Discover books, learn about writers, and more.

Product Description

From the Author

Its about concepts, algorithms, pitfalls, design; not source
To set expectations correctly, this book did not set out to show source code for debuggers. Instead it trys to fill a void and describe how debuggers work, what kinds of algorithms are required, what are the tricky things to watch out for and other conceptual level information. Source code for debuggers is long, convoluted and much too detailed for a work on this level.

From the Back Cover

A total guide to debuggers: what they do, how they work, and how to use them to produce better programs "Debuggers are the magnifying glass, the microscope, the logic analyzer, the profiler, and the browser with which a program can be examined."–Jonathan B. Rosenberg Debuggers are an indispensable tool in the development process. In fact, during the course of the average software project, more hours are spent debugging software than in compiling code. Yet, not many programmers really know how to constructively interpret the results they get back from debuggers. And even fewer know what makes these complex suites of algorithms and data structures tick. Now in this extremely accessible guide, Jonathan B. Rosenberg demystifies debuggers for programmers and shows them how to make better use of debuggers in their next projects. Taking a hands–on, problem–solving approach to a complex subject, Rosenberg explains how debuggers work and why programmers use them. Most importantly, he provides practical discussions of debugger algorithms and procedures for their use, accompanied by many practical examples. The author also discusses a wide variety of systems applications, from Microsoft′s Win32 debug API to a large parallel architecture. Visit our Web site at: http://www.wiley.com/compbooks/

Inside This Book (Learn More)
First Sentence
Having presented some of the possible varieties of debuggers in Chapter 1, I will focus the rest of this book on the algorithms, data structures, architecture, and inner workings of the most commonly used type of debugger: the symbolic (maps underlying machine representation back to user-created source code), graphical user-interface-based (presents windows or views of different aspects of the underlying application to the user in an interactive,windows-based fashion), application-oriented debugger (focused on user-written applications, not operating system components). Read the first page
Explore More
Concordance
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Customer Reviews

5 star
0
4 star
0
2 star
0
1 star
0
3.0 out of 5 stars
3.0 out of 5 stars
Most Helpful Customer Reviews
3 of 3 people found the following review helpful
3.0 out of 5 stars Not recomended for anyone who wants source code 29 Oct 1997
By A Customer
Format:Paperback
I purchased this book because I needed to write a debugger for Win32. While it does give hints about the necessary API calls and processes, it does not provide any source code and avoided many advanced topics. I was highly disappointed.
Comment | 
Was this review helpful to you?
Format:Paperback
The book doesn't contain much detail. It covers all most important aspects of the problem and treat all architectures, processors and operating systems equally, however wery rarely spends more than one page on each of them. For example MacOS debug API is described on less than one page. The information is also quite old. There are no information on MacOS X, but plenty of information on Windows 3.1 and Windows 95. It may be a good start point if you need to know something but definitelly not a book which you would like to use all the time. Especially that there are no code sources and no examples.
Comment | 
Was this review helpful to you?
Most Helpful Customer Reviews on Amazon.com (beta)
Amazon.com: 3.3 out of 5 stars  11 reviews
60 of 63 people found the following review helpful
1.0 out of 5 stars Superficial, Short: Skip it! 21 Jan 2001
By ThomasH - Published on Amazon.com
Format:Paperback
I recall the time, as I worked on a large parallel Unix debugger, and only slowly collected facts and scraps of necessary knowledge to progress. I always wondered, why not a single book was written, which would be solely devoted to the architecture, design and implementation of symbolic debuggers?

As I saw this book announced, my expectations were high. Could this be a help in organizing my knowledge about debuggers, collected so far from semi confidential industry reports or white papers, 3-4 dissertations, several implementations, plus some 10-15 conference papers with vague descriptions of implementations, claims of spectacular achievements or with mere theoretical ideas?

No, unfortunately this is not so. This book, or rather "a booklet" is very incomplete. It literally did not told me any single detail which I would not have known already. For example, missing is the description of the very standard Unix interface to control and hold a process. Since this is not a scientific book providing more generic foundations about process tracing (such as tracking of very long time running programs, replay techniques, generating snapshots etc. etc.) than I would at least expect a solid practice orientation. This should include a complete discussion of several assemblers and typical architectures, because they provide sometimes completely different means of implementing breakpoints, watchpoints or of support for threads. In many cases a debugger must be, or can be supported by a cooperating compiler. Several interesting ideas have been implemented in the back ends, which may greatly help supporting breakpoints, finding function prologues, dealing with exceptions and asynchronous signals. I also miss the specifications and a good comparison of the two most common formats holding symbolic information, Stabs and DWARF! Etc. etc., this list of missing facts and issues could go on and on.

Usually I call a book like this one "a blah blah novel." The author claims "I know something, but I will not tell what is it." Yes, there are debuggers, yes we can program them but a lot of code is necessary to do so, yes we can stop a process and advance it instruction by instruction. Yes, yes, I know all that.

I think that will have to keep waiting for a serious book about symbolic debugging! Any takers? If I only could write well...
19 of 21 people found the following review helpful
3.0 out of 5 stars Good if you are only interested in theory and not practice 5 May 1998
By "webgeekinc" - Published on Amazon.com
Format:Paperback
I have to disagree with the author. The purpose of learning about writing a debugger is to "write a debugger". Because there aren't *any* other books with practical code and examples, the author missed a golden opportunity to fill a gap.
My Win32 debugger has less than 200 lines of source code, so the assertion that debugger code is long and complex is completely false. The "concept" of debugging is a complex one, but the source code is not.
That's not to say that the book is completely useless. Some of the advice given in the book can not be found in any other resource. And without it, it probably would have taken me much longer to write my debugger. Writing a debugger is not as easy as writing any other kind of program, so the concepts covered in the book are important.
If you are interested in writing a Win32 debugger, my suggestion would be to get this book, but supplement it with an MSDN subscription (either online or on CDROM) and get the Microsoft Systems Journal CDROM with back-issues. With these three resources (and a LOT of patience) you'll be able to get your Win32 debugger up and running.
13 of 14 people found the following review helpful
5.0 out of 5 stars A Good introductory book 25 May 2000
By Hassan I Khan - Published on Amazon.com
Format:Paperback
Considering there are practically *no* books around that deals with debugger theory, I would label it a pioneering effort from Mr. Rosenberg.
True that it side steps or do not discuss in detail issues which most debugger *writers* would want to know, I can understand why the author named the book 'How debuggers Work' instead of 'How to write debuggers' or 'Debugger writing: Principles and Techniques' etc. Still it gets you going and clear lots of necessary concepts.
2 of 2 people found the following review helpful
3.0 out of 5 stars Very superficial and fragmented 5 Jan 2003
By J Jacob Jingleheimer Schmidt - Published on Amazon.com
Format:Paperback
If there were any alternative books on the topic, I'd give this one 1 star, rather than 3. But for some reason there aren't any, so one has to be extra charitable. The book is EXTREMELY superficial, badly structured, fragmentary, it truly looks like a few unrelated white papers written by a younger colleague/research assistant bound together and published under the head honcho's name, a hasty, half-hearted affair.

Since this is the only thing in print covering the topic, you can't go wrong reading it, but don't expect to gain much. Perhaps working through the gdb's source code is better. Well, there's no question, of course, it's better because it's a real thing, but you might want to read this book as well, it does contain randomly located bits and pieces of relevant information.

It would be really great if this book were reworked: cleaned up, meaningfully structured, and given more depth (as well as source code.) Not sure why that's not done--such a book would definitely be commercially successful.
6 of 8 people found the following review helpful
5.0 out of 5 stars A well written introduction to a very complex topic 13 Nov 1998
By A Customer - Published on Amazon.com
Format:Paperback
Kudos! I found this book to be insightful and informative. The hints about internal workings of debuggers gave me, as a software engineer, insights into how to write higher quality code. My use of debuggers is no longer shrouded in magic. Now I really understand what they're telling me.
Were these reviews helpful?   Let us know
Search Customer Reviews
Only search this product's reviews

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   


Look for similar items by category


Feedback