• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
  • Campbell Ritchie
  • Jeanne Boyarsky
  • Ron McLeod
  • Paul Clapham
  • Liutauras Vilda
  • paul wheaton
  • Rob Spoor
  • Devaka Cooray
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Frits Walraven
  • Tim Moores
  • Mikalai Zaikin

Robust Java: TOC?

Posts: 799
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Greetings Mr Stelting,

The book looks interesting and promising. I find that exception handling is usually an afterthought, and often not much of a thought at that.

Where can we find a table of contents? Do you have a page for the book?

Jeff L.
Ranch Hand
Posts: 56
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

I just found the information here.

Best regards,

Jan Rotthaus
Ranch Hand
Posts: 56
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
FYI: The link above also contains a sample chapter (#3: Advanced Exception Handling Concepts).
Posts: 19
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Hi Jeff,

Thanks very much for the request, and thank YOU Jan for providing a link to the Prentice Website! Here's another copy of my table of contents for the saloon.

Over the years, I've found that most Java developers get little practical grounding in how to deal with errors in code - just as you mentioned, Jeff. It's unfortunate, since common problems (and bad habits) tend to surface on a regular basis in most software projects. These problems ultimately undermine the stability of the software we work so hard to create! It's my hope that "Robust Java" helps to identify many of these problems, and provide some useful recommendations for how to reach reasonable solutions

I wrote the book in three parts, which target broad themes in software development. The first section covers what I tend to think of as "core programming skills" - stuff that any Java developer can use to write more solid code and handle exceptions effectively. The second covers what I broadly categorize as "design issues and considerations"; it talks about exception handling in application development, as well as the exception models for some key Java APIs. The last section moves into more global topics... architecture, patterns, testing and debugging.

Hope you find this useful,
Steve Stelting

Part 1 Fundamentals of Exceptions and Exception Handling
Chapter 1 Introducing Exceptions
Concept of Exceptions
The Exception Class Hierarchy
Handle or Declare Options for Exceptions
Checked and Unchecked Exceptions
The API for Exceptions
Chapter 2 Exception Handling Techniques and Practices
When to Handle and When to Declare
Standard Exception Handling Options
Do's and Dont's for Exception Handling
Chapter 3 Advanced Exception Handling Concepts
Custom Exceptions
Chaining Exceptions
Exception Localization and Internationalization
Exception Declaration for Interfaces and Abstract Classes
Exception Stack Traces
Low-Level Exception Handling
Chapter 4 Exceptions and Threading
Exceptions in Multithreaded Systems
Exceptions in Synchronized Code Blocks
Exception Risks Due to Threaded Activity
Exceptions for Thread-based Communication
Chapter 5 Logging and Assertions
When Should You Use the Logging API?
Overview of the Logging API
Detailed API Use
Standard Logging Configurations

Part 2 Exception Handling and Design
Chapter 6 Exception Handling and Design
Principles of Effective OO Design
Integrating Exceptions into OOD
Design for Maintainability - Benefits and Drawbacks
Failure Mode Analysis
Chapter 7 Exceptions in the Java Core Language
Primitive Data Types
The Object Class and Objects in Java
Interfaces in the java.lang Package
String and StringBuffer
BigDecimal and BigInteger
The Wrapper Classes
Chapter 8 Collections and I/O
The Collections Framework
The New I/O API
Chapter 9 Distributed Java APIs
Distributed Communication Fundamentals
RMI - Remote Method Invocation API
JNDI - The Java Naming and Directory Interface
JDBC - The Java Database Connectivity API
Chapter 10 J2EE
The J2EE Application Model
Client Tier
Web Tier
EJB Tier
Transactions in J2EE and EJBs
J2EE Exception Handling - Global Considerations
Factors to Consider for J2EE Exception Handling

Part 3 Effective Use of Exceptions, Errors and Handling
Chapter 11 Architecture, Design and the Exception Model
Why Should Architects Care About Exceptions and Errors?
Architecture, Design and Development
Key Architectural Decisions for the Exception Model
Chapter 12 Patterns
Architectural Patterns
Design Patterns
Creational Patterns
Structural Patterns
Behavioral Patterns
J2EE Patterns
Integration Tier
Presentation Tier
Business Tier
Chapter 13 Testing
What's the Purpose of Testing? Why is it so Important?
Common Misconceptions about Testing
Types of Testing: Thinking Outside (and Inside) the Box
If It Were Easy, We'd All Be Doing It: What Makes Testing Hard in Java?
Testing Practices
Tactics & Technologies: How Do You Manage and Run Tests?
When is Testing "Done"?
Chapter 14 Debugging
Demystifying Debugging: "It's Not a Bug, It's a..."
Debugging Principles, Debugging Practices
Debugging Strategies
Debugging Observables and Methods
Special Challenges for Debugging

Appendix A Profiling Test Results for Handle-Declare
Appendix B A Short, Friendly Tutorial for jUnit
Appendix C MyBuggyServlet - Validation Issues with a Component
Ranch Hand
Posts: 133
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

How in depth do you discuss "Profiling"? I notices it's listed in the title of Appendix A. I'm looking for information on profiling techniques (particularly with WebSphere Studio App. Developer).


With a little knowledge, a cast iron skillet is non-stick and lasts a lifetime.
    Bookmark Topic Watch Topic
  • New Topic