Have one to sell? Sell yours here
Debugging Java: Troubleshooting for Programmers
 
See larger image
 
Tell the Publisher!
I'd like to read this book on Kindle

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

Debugging Java: Troubleshooting for Programmers [Paperback]

Will D. Mitchell (Author), Will David Mitchell (Author)
3.2 out of 5 stars  See all reviews (15 customer reviews)


Available from these sellers.


Textbook Student FREE Two-Day Shipping for Students. Learn more

Formats

Amazon Price New from Used from
Paperback --  

Book Description

0072125624 978-0072125627 July 12, 2000 1st
-- Troubleshooting reference for the Java programmer.
-- Author's computer science teaching experience led him to discover the importance of debugging. His research showed that people who learn debugging skills first, master computer languages markedly faster.
-- Stands alone and can be paired with other Debugging titles covering C++, ASP, and other technologies.
-- Filled with solutions to common and rare bugs.
-- Proactive focus helps developers identify bad coding habits and adopt strategies to build clean code.


Editorial Reviews

From the Back Cover

Write Error-Free Programs from Development to Deployment

Kill Java bugs dead with the tips, tricks, and advanced troubleshooting techniques in this comprehensive volume. Debugging Java shows you, step-by-step, how to locate and eliminate common and hard-to-find rough spots in your applets and applications. You'll learn how to prevent bugs from hatching in your code, avoid scope creep, reduce deadline pressure using RFA, use text editors and macros to reduce errors, use debugging power tools, and eliminate multi-thread conflicts. Debugging expert Will David Mitchell even shows you how potential design and logic flaws can spark new features! When "it works on my machine" just won't cut it, use the hands-on solutions offered in this resource to exterminate Java bugs for good.

  • Learn the architecture of clean Java code and eliminate bad programming habits
  • Set effective traps to locate and squash Java bugs
  • Find, analyze, and fix object-oriented and procedure-oriented code errors and trouble spots
  • Use Risk-Factor Analysis to eliminate bugs caused by deadline pressure
  • Implement robust macros to cut errors and save time
  • Extend and train the Copy/Paste buffer to avoid typing errors
  • Identify and remove conditions that may lead to mutually conflicting threads

About the Author

David Mitchell (Bellevue, NE) while teaching computer science at the University of Nebraska, David's research showed that people who learned debugging skills first, master computer languages markedly faster. He has authored more than a thousand technical manuals and papers since 1971, including five high-tech thriller novels. His popular website for authors is http://weblications.net. Besides being an author and computer scientist, he is a jet pilot, a mathematician, an artist and a musician.

Product Details

  • Paperback: 500 pages
  • Publisher: McGraw-Hill Companies; 1st edition (July 12, 2000)
  • Language: English
  • ISBN-10: 0072125624
  • ISBN-13: 978-0072125627
  • Product Dimensions: 9.2 x 7.4 x 1.2 inches
  • Shipping Weight: 1.7 pounds
  • Average Customer Review: 3.2 out of 5 stars  See all reviews (15 customer reviews)
  • Amazon Best Sellers Rank: #2,687,206 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

 

Customer Reviews

15 Reviews
5 star:
 (4)
4 star:
 (4)
3 star:
 (1)
2 star:
 (3)
1 star:
 (3)
 
 
 
 
 
Average Customer Review
3.2 out of 5 stars (15 customer reviews)
 
 
 
 
Share your thoughts with other customers:
Most Helpful Customer Reviews

12 of 13 people found the following review helpful:
5.0 out of 5 stars This book is money for IT professionals, September 14, 2000
By A Customer
This review is from: Debugging Java: Troubleshooting for Programmers (Paperback)
This book is money. The ideas and concepts in this book will probably recoup the book's cost many times over every month you remain in the industry. It is hard to discuss technical matters in a clear manner. Will Mitchell does so with warmth, wit and humor. No mean feat in a technical book. This guy actually tries to explain his ideas, not impress us with his intellect. Probably 60% of this book will be useful long after Java is an old dusty language that people used to use. I think that just about everyone in data processing would benefit from this book whether they use Java or not. I have been programming for over twenty years and I wish I could have read this book in the beginning. I have learned most of these principles and ideas the hard way. The rest not at all until now.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


7 of 7 people found the following review helpful:
1.0 out of 5 stars Only old-timers and newbies will like this book, January 9, 2002
This review is from: Debugging Java: Troubleshooting for Programmers (Paperback)
First let me say I liked the writing style and it was enjoyable to read. I was able to finish the book cover to cover in 3 days of casual reading. I did get something useful out of the book. He talked about right-brain versus left-brain activity which I found interesting and helpful for my job.

I've made the mistake of reading Extreme programming and Refactoring BEFORE reading this book. So for example in this book the author spends great detail on how to count in a large switch case statement how many case: elements you should have and how to quickly check it. If you've read Refactoring by Fowler you would instantly hear alarms in your head telling you your NOT using OO corectly and that this bad code should be refactored. If you want a good OO/Design Patterns book I would recomend Cooper's book. You better understand Design Patterns if your going to code in Java or you will have a tough time when it comes to I/O and Swing classes.

Two finally points to make on the downside of this book.
1. The author mentions 'goto' and does not correctly tell the history of why the word is reserved. James Gosling at OPSLA on year informed the audience that a technical writer was documenting 'goto' and wanted him to explain it. When James did a grep against the code base he saw it used 10 times of which only 3 where valid in his opinion. James then decided it was easier to remove it than it was to have it documented. James felt that continue and break statements handled all cases that goto were being used in the system.

2. The exception model in C++ is just plain broken and the author does not do a good job of explaining what Java did to fix this problem. In a very large C++ system any 3rd party library could throw an exception that is un-advertised. Exceptions in C++ are checked at runtime. The Java compiler checks exceptions at compile time. In java you could never add a 3rd party jar file and have an exception thrown that is not advertised in the interface of the class or method.

Java is an OO language and to debug in Java you better know OO and you better understand threads and java.object or your going to have a long night. The author should have started here and delved deaper instead of wasting paper on MS Word and Word macros for coding.

Ah...
Before I forget. If you read the book PLEASE don't use /** QQQ*/
as a tag in your code. If you've got JBuilder use /** todo */ or something non-cryptic to document coding in progress comments.

Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


6 of 6 people found the following review helpful:
2.0 out of 5 stars Is He Serious?, November 5, 2001
By 
Greg Tomkins (North Vancouver, British Columbia Canada) - See all my reviews
(REAL NAME)   
This review is from: Debugging Java: Troubleshooting for Programmers (Paperback)
A while back I picked up 'Debugging VB' and didn't think much of it. At first I thought 'Debugging Java' was better, but the author completely blew his credibility on three counts:

1. Not only does he recommend using MS Word as a Java IDE, he goes to some length to provide macros and so on to show how to achieve context-sensitive highlighting and so on. In fact, at the back of the book, several pages are devoted to this very thing.

2. At one point he writes with pride about how he whipped up a 'report generator' in Basic that cranked out 25 copies of boilerplate COBOL. Precisely the kind of code that Java's inheritance and object composition paradigms are intended to avoid. Some people never learn!

3. In a similar vein, he also takes about a faux Javadoc he developed that cranked out 1" of documentation in half a day. This fellow seems to prefer quantity over quality.

On the plus side, this book had a better-than-average discussion of the various IDE's (other than Word!), and is worth a quick peruse to see what they all look like, if you haven't already.

Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No

Share your thoughts with other customers: Create your own review
 
 
 
Most Recent Customer Reviews











Only search this product's reviews



Tags Customers Associate with This Product

 (What's this?)
Click on a tag to find related items, discussions, and people.
 

Your tags: Add your first tag
 

Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

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
 


Active discussions in related forums
Search Customer Discussions
Search all Amazon discussions
   
Related forums



So You'd Like to...


Create a guide


Look for Similar Items by Category


Look for Similar Items by Subject