Study Topics

Study Topics
- Project / Time / Process Management
  - Absolute Beginner's Guide to Project Management
    - Part i. Project Management Jumpstart
      - Chapter 1. Project Management Overview
      - What Is Project Management…Exactly?
      - What Is the Value of Project Management?
      - Why Are Projects Challenging?
      - Growing Demand for Effective Project Managers?
      - Trends in Project Management
        Chapter 2. The Project Manager
      - One Title, Many Roles
      - Key Skills of Project Managers
      - Qualities of Successful Project Managers
      - 15 Common Mistakes of Project Managers
        Chapter 3. Essential Elements for any Successful Project
      - What Exactly Is a "Successful" Project?
      - Learning from Troubled Projects
      - Learning from Successful Projects
      - Essential Project Manager Toolkit
    - Part ii. Project Planning
      - Chapter 4. Defining a Project
      - Setting the Stage for Success
      - How Does Defining a Project Relate to Project Planning?
      - Project Definition Document
      - Project Definition Checklist
        Chapter 5. Planning a Project
      - Key Project Planning Principles
      - Important Questions Project Planning Should Answer
      - Building a Project Plan
      - Summary of Supplemental Project Plan Components
      - Project Plan Checklist
        Chapter 6. Developing the Work Breakdown Structure
      - What Is a WBS Exactly?
      - Why Is the WBS Important?
      - The Process of Building a WBS
        Chapter 7. Estimating the Work
      - Next Step in the Schedule Development Process
      - Managing the Risk, Managing the Estimates
      - Reasons for Estimating Woes
      - Powerful Estimating Techniques and Methods
      - Best Practices
        Chapter 8. Developing the Project Schedule
      - The Impact of the Project Schedule
      - The Goal of the Schedule Development Process
      - Key Inputs for Building a Schedule
      - Creating a Schedule
        Chapter 9. Determining the Project Budget
      - The Impact of the Project Budget
      - Principles of an Effective Budget
      - Creating a Project Budget
      - Common Budget Challenges
    - Part iii. Project Control
      - Chapter 10. Controlling a Project
      - What Is Project Control?
      - Management Fundamentals for Project Control
      - Powerful Techniques for Project Control
      - Performance Reporting
      - Variance Responses
      - Leveraging Earned Value Management Concepts
      - Common Project Control Challenges
      - Lessons from Project Recoveries
        Chapter 11. Managing Project Changes
      - What Exactly Is a Project Change and What's the Big Deal Anyway?
      - Fundamentals for Managing Project Change
      - What Causes Unplanned Scope Changes?
      - Essential Elements of a Project Change Control System
      - Powerful Techniques for Minimizing Project Changes
      - Common Project Change Control Challenges
        Chapter 12. Managing Project Deliverables
      - "Managing Project Deliverables" Means What Exactly?
      - Why Do This? It's Too Much Work
      - Identify, Protect, and Track: The Principles of Managing Work Products
      - Best Practices
      - Configuration Management Plan
      - Common Challenges and Pitfalls
        Chapter 13. Managing Project Issues
      - The Goals, Objectives, and Principles of Project Issue Management
      - Key Features of Issue Management System
      - Options for Issue Log
      - Best Practices
      - Some Special Situations
        Chapter 14. Managing Project Risks
      - Key Risk Management Principles
      - The Essential Process for Managing Project Risks
      - The Common Sources of Project Risk
      - Typical Problems
      - Powerful Risk Control Strategies
      - Are You Sure It's a Risk?
        Chapter 15. Managing Project Quality
      - What Is "Project Quality"?
      - Unique Aspects of Managing Project Quality
      - Principles of Managing Project Quality
      - Powerful Tools and Techniques for Project Quality
      - Powerful Quality Strategies
      - Typical Quality-Related Challenges
    - Part iv. Project Execution
      - Chapter 16. Leading a Project
      - More Than Managing
      - Where Is Leadership Needed on a Project?
      - Twelve Keys to Better Project Leadership
      - Power of Servant Leadership Approach
        Chapter 17. Managing Project Communications
      - What Are Project Communications?
      - The Importance of Project Communications
      - Why Communicating Can Be Tough
      - Seven Powerful Principles
      - Best Practices of Effective Project Communicators
        Chapter 18. Managing Expectations
      - Value of Reviewing Stakeholder Expectation Management
      - Critical Aspects of Expectations
      - Seven Master Principles of Expectation Management
      - Essential Elements of Managing Expectations
        Chapter 19. Keys to Better Project Team Performance
      - High-Performing Teams
      - Ten Key Principles
      - Proven Techniques
      - Special Situations
        Chapter 20. Managing Differences
      - Five Key Principles
      - Proven Techniques for Leading Cross-Functional Projects
      - Proven Techniques for Leading Cross-Cultural Projects
      - Proven Techniques for Leading Virtual Projects
        Chapter 21. Managing Vendors
      - First, Let's Clarify a Few Terms
      - Ten Proven Principles of Vendor Management
      - Twelve Tips for Buyers
      - Seven Tips for Sellers
      - Twelve Key Project Management Skills for Better Vendor Management
      - Stuff You Need to Know About Contracts
        Chapter 22. Ending a Project
      - Three Key Principles
      - Project End Checklist—13 Important Steps
      - Common Project Closing Challenges
      - Methods for Ending a Contract or a Project
  - The Art of Project Management by Scott Berkun Publisher: O'Reilly Pub Date: April 2005 ISBN: 0-596-00786-8 Pages: 392
    - Chapter One. A brief history of project management (and why you should care)
    - Section 1.1. Using history
    - Section 1.2. Web development, kitchens, and emergency rooms
    - Section 1.3. The role of project management
    - Section 1.4. Program and project management at Microsoft
    - Section 1.5. The balancing act of project management
    - Section 1.6. Pressure and distraction
    - Section 1.7. The right kind of involvement
    - Section 1.8. Summary
    - Part I: Plans
      - Chapter Two. The truth about schedules
      - Section 2.1. Schedules have three purposes
      - Section 2.2. Silver bullets and methodologies
      - Section 2.3. What schedules look like
      - Section 2.4. Why schedules fail
      - Section 2.5. What must happen for schedules to work
      - Section 2.6. Summary
        Chapter Three. How to figure out what to do
      - Section 3.1. Software planning demystified
      - Section 3.2. Approaching plans: the three perspectives
      - Section 3.3. The magical interdisciplinary view
      - Section 3.4. Asking the right questions
      - Section 3.5. Catalog of common bad ways to decide what to do
      - Section 3.6. The process of planning
      - Section 3.7. Customer research and its abuses
      - Section 3.8. Bringing it all together: requirements
        Chapter Four. Writing the good vision
      - Section 4.1. The value of writing things down
      - Section 4.2. How much vision do you need?
      - Section 4.3. The five qualities of good visions
      - Section 4.4. The key points to cover
      - Section 4.5. On writing well
      - Section 4.6. Drafting, reviewing, and revising
      - Section 4.7. A catalog of lame vision statements (which should be avoided)
      - Section 4.8. Examples of visions and goals
      - Section 4.9. Visions should be visual
      - Section 4.10. The vision sanity check: daily worship
      - Section 4.11. Summary
        Chapter Five. Where ideas come from
      - Section 5.1. The gap from requirements to solutions
      - Section 5.2. There are bad ideas
      - Section 5.3. Thinking in and out of boxes is OK
      - Section 5.4. Good questions attract good ideas
      - Section 5.5. Bad ideas lead to good ideas
      - Section 5.6. Perspective and improvisation
      - Section 5.7. The customer experience starts the design
      - Section 5.8. A design is a series of conversations
      - Section 5.9. Summary
        Chapter Six. What to do with ideas once you have them
      - Section 6.1. Ideas get out of control
      - Section 6.2. Managing ideas demands a steady hand
      - Section 6.3. Checkpoints for design phases
      - Section 6.4. How to consolidate ideas
      - Section 6.5. Prototypes are your friends
      - Section 6.6. Questions for iterations
      - Section 6.7. The open-issues list
      - Section 6.8. Summary
    - Part II: Skills
      - Chapter Seven. Writing good specifications
      - Section 7.1. What specifications can and cannot do
      - Section 7.2. Deciding what to specify
      - Section 7.3. Specifying is not designing
      - Section 7.4. Who, when, and how
      - Section 7.5. When are specs complete?
      - Section 7.6. Reviews and feedback
      - Section 7.7. Summary
        Chapter Eight. How to make good decisions
      - Section 8.1. Sizing up a decision (what's at stake)
      - Section 8.2. Finding and weighing options
      - Section 8.3. Information is a flashlight
      - Section 8.4. The courage to decide
      - Section 8.5. Paying attention and looking back
      - Section 8.6. Summary
        Chapter Nine. Communication and relationships
      - Section 9.1. Management through conversation
      - Section 9.2. A basic model of communication
      - Section 9.3. Common communication problems
      - Section 9.4. Projects depend on relationships
      - Section 9.5. The best work attitude
      - Section 9.6. Summary
        Chapter Ten. How not to annoy people: process, email, and meetings
      - Section 10.1. A summary of why people get annoyed
      - Section 10.2. The effects of good process
      - Section 10.3. Non-annoying email
      - Section 10.4. How to run the non-annoying meeting
      - Section 10.5. Summary
        Chapter Eleven. What to do when things go wrong
      - Section 11.1. Apply the rough guide
      - Section 11.2. Common situations to expect
      - Section 11.3. Take responsibility
      - Section 11.4. Damage control
      - Section 11.5. Conflict resolution and negotiation
      - Section 11.6. Roles and clear authority
      - Section 11.7. An emotional toolkit: pressure, feelings about feelings, and the hero complex
      - Section 11.8. Summary
    - Part III: Management
      - Chapter Twelve. Why leadership is based on trust
      - Section 12.1. Building and losing trust
      - Section 12.2. Make trust clear (create green lights)
      - Section 12.3. The different kinds of power
      - Section 12.4. Trusting others
      - Section 12.5. Trust is insurance against adversity
      - Section 12.6. Models, questions, and conflicts
      - Section 12.7. Trust and making mistakes
      - Section 12.8. Trust in yourself (self-reliance)
      - Section 12.9. Summary
        Chapter Thirteen. How to make things happen
      - Section 13.1. Priorities make things happen
      - Section 13.2. Things happen when you say no
      - Section 13.3. Keeping it real
      - Section 13.4. Know the critical path
      - Section 13.5. Be relentless
      - Section 13.6. Be savvy
      - Section 13.7. Summary
        Chapter Fourteen. Middle-game strategy
      - Section 14.1. Flying ahead of the plane
      - Section 14.2. Taking safe action
      - Section 14.3. The coding pipeline
      - Section 14.4. Hitting moving targets
      - Section 14.5. Summary
        Chapter Fifteen. End-game strategy
      - Section 15.1. Big deadlines are just several small deadlines
      - Section 15.2. Elements of measurement
      - Section 15.3. Elements of control
      - Section 15.4. The end of end-game
      - Section 15.5. Party time
      - Section 15.6. Summary
        Chapter Sixteen. Power and politics
      - Section 16.1. The day I became political
      - Section 16.2. The sources of power
      - Section 16.3. The misuse of power
      - Section 16.4. How to solve political problems
      - Section 16.5. Know the playing field
      - Section 16.6. Summary
  - Time Management for System Administrators by Thomas A. Limoncelli Publisher: O'Reilly Pub Date: November 2005 ISBN: 0-596-00783-3 Pages: 226
    - Chapter 1. Time Management Principles
      - Section 1.1. What's So Difficult About Time Management?
      - Section 1.2. The Principles of Time Management for SAs
      - Section 1.3. It Won't Be Easy
      - Section 1.4. Summary
    - Chapter 2. Focus Versus Interruptions
      - Section 2.1. The Focused Brain
      - Section 2.2. An Environment to Encourage Focus
      - Section 2.3. Interruptions
      - Section 2.4. Directing Interruptions Away from You
      - Section 2.5. You Can Say "Go Away" Without Being a Jerk
      - Section 2.6. Summary
    - Chapter 3. Routines
      - Section 3.1. Sample Routines
      - Section 3.2. How to Develop Your Own Routines
      - Section 3.3. Deleting Old Routines
      - Section 3.4. Summary
    - Chapter 4. The Cycle System
      - Section 4.1. Don't Trust Your Brain
      - Section 4.2. Why Other Systems Fail
      - Section 4.3. Systems That Succeed
      - Section 4.4. The Cycle
      - Section 4.5. Summary
    - Chapter 5. The Cycle System: To Do Lists and Schedules
      - Section 5.1. A Sample Day
      - Section 5.2. Other Tips
      - Section 5.3. Setting Up a PAA for Use with The Cycle
      - Section 5.4. Setting Up a PDA for Use with The Cycle
      - Section 5.5. Summary
    - Chapter 6. The Cycle System: Calendar Management
      - Section 6.1. How to Use Your Calendar
      - Section 6.2. One Calendar for Business and Social Life
      - Section 6.3. Repeating Tasks
      - Section 6.4. Know Your Personal Rhythms
      - Section 6.5. Know Your Company's Rhythms
      - Section 6.6. Summary
    - Chapter 7. The Cycle System: Life Goals
      - Section 7.1. The Secret Trick
      - Section 7.2. Setting Goals
      - Section 7.3. Planning Your Next Steps
      - Section 7.4. Schedule the Steps
      - Section 7.5. Revisit Your Goals Regularly
      - Section 7.6. Summary
    - Chapter 8. Prioritization
      - Section 8.1. Prioritizing Your To Do Lists
      - Section 8.2. Project Priorities
      - Section 8.3. Requests from Your Boss
      - Section 8.4. Summary
    - Chapter 9. Stress Management
      - Section 9.1. Overload and Conflicting Directions
      - Section 9.2. Vacation Time
      - Section 9.3. Yoga, Meditation, and Massage
      - Section 9.4. Summary
    - Chapter 10. Email Management
      - Section 10.1. Managing Your Email
      - Section 10.2. Jump Starting the Process
      - Section 10.3. Summary
    - Chapter 11. Eliminating Time Wasters
      - Section 11.1. What Is a Time Waster?
      - Section 11.2. Avoiding the Tempting Time Wasters
      - Section 11.3. Common Time Wasters
      - Section 11.4. Wasteful Meetings
      - Section 11.5. Strategic Versus Tactical
      - Section 11.6. Summary
    - Chapter 12. Documentation
      - Section 12.1. Document What Matters to You
      - Section 12.2. Wiki Technology
      - Section 12.3. Summary
    - Chapter 13. Automation
      - Section 13.1. What to Automate?
      - Section 13.2. How to Automate
      - Section 13.3. Simple Things Done Often
      - Section 13.4. Hard Things Done Once
      - Section 13.5. Letting Others Do Privileged Operations
      - Section 13.6. Summary
  - How to Cheat at IT Project Management
    - Chapter 1. What's Project Management Got To Do With IT?
      - Section 1.1. Introduction
      - Section 1.2. Business Process Improvement Systems
      - Section 1.3. Overview of Project Management
      - Section 1.4. Project Success Factors
      - Section 1.5. Four Project Constraints
      - Section 1.6. Projects, Programs, and Portfolios
      - Section 1.7. Summary
      - Section 1.8. Solutions Fast Track
      - Section 1.9. Frequently Asked Questions
    - Chapter 2. What's Corporate Strategy Got To Do With IT?
      - Section 2.1. Introduction
      - Section 2.2. Overview of Corporate Strategy in Today's Environment
      - Section 2.3. Aligning IT with Corporate Strategy: Taking It One Step Further
      - Section 2.4. Understanding Your Company's Strategies
      - Section 2.5. Developing Your IT Strategy
      - Section 2.6. Assessing Your Current IT Environment
      - Section 2.7. Developing Your IT Operational Roadmap
      - Section 2.8. Summary
      - Section 2.9. Solutions Fast Track
      - Section 2.10. Frequently Asked Questions
    - Chapter 3. Navigating Corporate Politics
      - Section 3.1. Introduction
      - Section 3.2. Corporate Politics: A Primer
      - Section 3.3. Understanding Sources of Power
      - Section 3.4. Understanding Methods of Influence
      - Section 3.5. The Power Paradox
      - Section 3.6. Working Effectively in a Political Environment
      - Section 3.7. Breaking Up Political Logjams
      - Section 3.8. Effective Countermeasures
      - Section 3.9. Summary
      - Section 3.10. Solutions Fast Track
      - Section 3.11. Frequently Asked Questions
    - Chapter 4. Managing the IT Project Team
      - Section 4.1. Introduction
      - Section 4.2. Today's Management Environment
      - Section 4.3. What People Really Want
      - Section 4.4. Work Styles and the Project Team
      - Section 4.5. Culture Matters
      - Section 4.6. Men, Women, and Technology
      - Section 4.7. Developing High Performance Teams
      - Section 4.8. Summary
      - Section 4.9. Solutions Fast Track
      - Section 4.10. Frequently Asked Questions
    - Chapter 5. Defining IT Projects
      - Section 5.1. Introduction
      - Section 5.2. Project Management Process Overview
      - Section 5.3. Project Origins
      - Section 5.4. Validating the Project Proposal
      - Section 5.5. Defining the Project
      - Section 5.6. Developing the Project Proposal
      - Section 5.7. Identifying the Project Sponsor
      - Section 5.8. Gaining Validated Project Proposal Approval
      - Section 5.9. Summary
      - Section 5.10. Solutions Fast Track
      - Section 5.11. Frequently Asked Questions
    - Chapter 6. Organizing IT Projects
      - Section 6.1. Introduction
      - Section 6.2. Identifying Project Objectives
      - Section 6.3. Identifying Stakeholders
      - Section 6.4. Identifying Project Requirements
      - Section 6.5. Refining Project Parameters
      - Section 6.6. Defining Project Infrastructure
      - Section 6.7. Defining Project Processes
      - Section 6.8. Summary
      - Section 6.9. Solutions Fast Track
      - Section 6.10. Frequently Asked Questions
    - Chapter 7. Quality From the Ground Up
      - Section 7.1. Introduction
      - Section 7.2. Quality Overview
      - Section 7.3. Planning Quality
      - Section 7.4. Monitoring Quality
      - Section 7.5. Testing Quality
      - Section 7.6. Summary
      - Section 7.7. Solutions Fast Track
      - Section 7.8. Frequently Asked Questions
    - Chapter 8. Forming the IT Project Team
      - Section 8.1. Introduction
      - Section 8.2. Identifying Project Team Requirements
      - Section 8.3. Identifying Staffing Requirements and Constraints
      - Section 8.4. Defining Roles and Responsibilities
      - Section 8.5. Acquiring Needed Staff
      - Section 8.6. Forming the Team
      - Section 8.7. Summary
      - Section 8.8. Solutions Fast Track
      - Section 8.9. Frequently Asked Questions
    - Chapter 9. Planning IT Projects
      - Section 9.1. Introduction
      - Section 9.2. Creating the Work Breakdown Structure
      - Section 9.3. Creating A Network Diagram
      - Section 9.4. Creating the Project Schedule
      - Section 9.5. Creating the Project Budget
      - Section 9.6. Identifying Project Risks
      - Section 9.7. Planning Project Communications
      - Section 9.8. Finalizing the Project Plan
      - Section 9.9. Summary
      - Section 9.10. Solutions Fast Track
      - Section 9.11. Frequently Asked Questions
    - Chapter 10. Managing IT Projects
      - Section 10.1. Introduction
      - Section 10.2. Initiating Project Work
      - Section 10.3. Monitoring Project Progress
      - Section 10.4. Managing Project Change
      - Section 10.5. Managing Project Risk
      - Section 10.6. Managing the Project Team
      - Section 10.7. Summary
      - Section 10.8. Solutions Fast Track
      - Section 10.9. Frequently Asked Questions
    - Chapter 11. Tracking IT Projects
      - Section 11.1. Introduction
      - Section 11.2. Technical Tracking Tools
      - Section 11.3. Testing Project Deliverables
      - Section 11.4. Preparing for Implementation, Deployment, and Operational Transfer
      - Section 11.5. Resolving Common Project Problems
      - Section 11.6. Summary
      - Section 11.7. Solutions Fast Track
      - Section 11.8. Frequently Asked Questions
    - Chapter 12. Closing Out IT Projects
      - Section 12.1. Introduction
      - Section 12.2. Closing Out Project Activities
      - Section 12.3. Preparing Final Documentation
      - Section 12.4. Final Project Sign-Off
      - Section 12.5. Review Lessons Learned
      - Section 12.6. Administrative Closure
      - Section 12.7. Final Team Meeting
      - Section 12.8. Summary
      - Section 12.9. Solutions Fast Track
      - Section 12.10. Frequently Asked Questions
  - Applied Software Project Management
    - Chapter 1. Introduction
      - Section 1.1. Tell Everyone the Truth All the Time
      - Section 1.2. Trust Your Team
      - Section 1.3. Review Everything, Test Everything
      - Section 1.4. All Software Engineers Are Created Equal
      - Section 1.5. Doing the Project Right Is Most Efficient
      - Section 1.6. Part I: Tools and Techniques
      - Section 1.7. Part II: Using Project Management Effectively
    - Part I: Tools and Techniques
      - Chapter 2. Software Project Planning
      - Section 2.1. Understand the Project Needs
      - Section 2.2. Create the Project Plan
      - Section 2.3. Diagnosing Project Planning Problems
        Chapter 3. Estimation
      - Section 3.1. Elements of a Successful Estimate
      - Section 3.2. Wideband Delphi Estimation
      - Section 3.3. Other Estimation Techniques
      - Section 3.4. Diagnosing Estimation Problems
        Chapter 4. Project Schedules
      - Section 4.1. Building the Project Schedule
      - Section 4.2. Managing Multiple Projects
      - Section 4.3. Use the Schedule to Manage Commitments
      - Section 4.4. Diagnosing Scheduling Problems
        Chapter 5. Reviews
      - Section 5.1. Inspections
      - Section 5.2. Deskchecks
      - Section 5.3. Walkthroughs
      - Section 5.4. Code Reviews
      - Section 5.5. Pair Programming
      - Section 5.6. Use Inspections to Manage Commitments
      - Section 5.7. Diagnosing Review Problems
        Chapter 6. Software Requirements
      - Section 6.1. Requirements Elicitation
      - Section 6.2. Use Cases
      - Section 6.3. Software Requirements Specification
      - Section 6.4. Change Control
      - Section 6.5. Introduce Software Requirements Carefully
      - Section 6.6. Diagnosing Software Requirements Problems
        Chapter 7. Design and Programming
      - Section 7.1. Review the Design
      - Section 7.2. Version Control with Subversion
      - Section 7.3. Refactoring
      - Section 7.4. Unit Testing
      - Section 7.5. Use Automation
      - Section 7.6. Be Careful with Existing Projects
      - Section 7.7. Diagnosing Design and Programming Problems
        Chapter 8. Software Testing
      - Section 8.1. Test Plans and Test Cases
      - Section 8.2. Test Execution
      - Section 8.3. Defect Tracking and Triage
      - Section 8.4. Test Environment and Performance Testing
      - Section 8.5. Smoke Tests
      - Section 8.6. Test Automation
      - Section 8.7. Postmortem Reports
      - Section 8.8. Using Software Testing Effectively
      - Section 8.9. Diagnosing Software Testing Problems
    - Part II: Using Project Management Effectively
      - Chapter 9. Understanding Change
      - Section 9.1. Why Change Fails
      - Section 9.2. How to Make Change Succeed
        Chapter 10. Management and Leadership
      - Section 10.1. Take Responsibility
      - Section 10.2. Do Everything Out in the Open
      - Section 10.3. Manage the Organization
      - Section 10.4. Manage Your Team
        Chapter 11. Managing an Outsourced Project
      - Section 11.1. Prevent Major Sources of Project Failure
      - Section 11.2. Management Issues in Outsourced Projects
      - Section 11.3. Collaborate with the Vendor
        Chapter 12. Process Improvement
      - Section 12.1. Life Without a Software Process
      - Section 12.2. Software Process Improvement
      - Section 12.3. Moving Forward
        Download this chapter Bibliography
      - Chapter 2. Software Project Planning
      - Chapter 3. Estimation
      - Chapter 4. Project Schedules
      - Chapter 5. Reviews
      - Chapter 6. Software Requirements
      - Chapter 7. Design and Programming
      - Chapter 8. Software Testing
      - Chapter 9. Understanding Change
      - Chapter 10. Management and Leadership
      - Chapter 11. Managing an Outsourced Project
      - Chapter 12. Process Improvement
  - Code Complete, Second Edition
    - Part I: Laying the Foundation
      - In this part:
      - Chapter 1. Welcome to Software Construction
      - Section 1.1. What Is Software Construction?
      - Section 1.2. Why Is Software Construction Important?
      - Section 1.3. How to Read This Book
      - Key Points
      - Chapter 2. Metaphors for a Richer Understanding of Software Development
      - Section 2.1. The Importance of Metaphors
      - Section 2.2. How to Use Software Metaphors
      - Section 2.3. Common Software Metaphors
      - Key Points
      - Chapter 3. Measure Twice, Cut Once: Upstream Prerequisites
      - Section 3.1. Importance of Prerequisites
      - Section 3.2. Determine the Kind of Software You're Working On
      - Section 3.3. Problem-Definition Prerequisite
      - Section 3.4. Requirements Prerequisite
      - Section 3.5. Architecture Prerequisite
      - Section 3.6. Amount of Time to Spend on Upstream Prerequisites
      - Additional Resources
      - Key Points
      - Chapter 4. Key Construction Decisions
      - Section 4.1. Choice of Programming Language
      - Section 4.2. Programming Conventions
      - Section 4.3. Your Location on the Technology Wave
      - Section 4.4. Selection of Major Construction Practices
      - Key Points
    - Part II: Creating High-Quality Code
      - In this part:
      - Chapter 5. Design in Construction
      - Section 5.1. Design Challenges
      - Section 5.2. Key Design Concepts
      - Section 5.3. Design Building Blocks: Heuristics
      - Section 5.4. Design Practices
      - Section 5.5. Comments on Popular Methodologies
      - Additional Resources
      - Key Points
      - Chapter 6. Working Classes
      - Section 6.1. Class Foundations: Abstract Data Types (ADTs)
      - Section 6.2. Good Class Interfaces
      - Section 6.3. Design and Implementation Issues
      - Section 6.4. Reasons to Create a Class
      - Section 6.5. Language-Specific Issues
      - Section 6.6. Beyond Classes: Packages
      - Additional Resources
      - Key Points
      - Chapter 7. High-Quality Routines
      - Section 7.1. Valid Reasons to Create a Routine
      - Section 7.2. Design at the Routine Level
      - Section 7.3. Good Routine Names
      - Section 7.4. How Long Can a Routine Be?
      - Section 7.5. How to Use Routine Parameters
      - Section 7.6. Special Considerations in the Use of Functions
      - Section 7.7. Macro Routines and Inline Routines
      - Key Points
      - Chapter 8. Defensive Programming
      - Section 8.1. Protecting Your Program from Invalid Inputs
      - Section 8.2. Assertions
      - Section 8.3. Error-Handling Techniques
      - Section 8.4. Exceptions
      - Section 8.5. Barricade Your Program to Contain the Damage Caused by Errors
      - Section 8.6. Debugging Aids
      - Section 8.7. Determining How Much Defensive Programming to Leave in Production Code
      - Section 8.8. Being Defensive About Defensive Programming
      - Additional Resources
      - Key Points
      - Chapter 9. The Pseudocode Programming Process
      - Section 9.1. Summary of Steps in Building Classes and Routines
      - Section 9.2. Pseudocode for Pros
      - Section 9.3. Constructing Routines by Using the PPP
      - Section 9.4. Alternatives to the PPP
      - Key Points
    - Part III: Variables
      - In this part:
      - Chapter 10. General Issues in Using Variables
      - Section 10.1. Data Literacy
      - Section 10.2. Making Variable Declarations Easy
      - Section 10.3. Guidelines for Initializing Variables
      - Section 10.4. Scope
      - Section 10.5. Persistence
      - Section 10.6. Binding Time
      - Section 10.7. Relationship Between Data Types and Control Structures
      - Section 10.8. Using Each Variable for Exactly One Purpose
      - Key Points
      - Chapter 11. The Power of Variable Names
      - Section 11.1. Considerations in Choosing Good Names
      - Section 11.2. Naming Specific Types of Data
      - Section 11.3. The Power of Naming Conventions
      - Section 11.4. Informal Naming Conventions
      - Section 11.5. Standardized Prefixes
      - Section 11.6. Creating Short Names That Are Readable
      - Section 11.7. Kinds of Names to Avoid
      - Key Points
      - Chapter 12. Fundamental Data Types
      - Section 12.1. Numbers in General
      - Section 12.2. Integers
      - Section 12.3. Floating-Point Numbers
      - Section 12.4. Characters and Strings
      - Section 12.5. Boolean Variables
      - Section 12.6. Enumerated Types
      - Section 12.7. Named Constants
      - Section 12.8. Arrays
      - Section 12.9. Creating Your Own Types (Type Aliasing)
      - Key Points
      - Chapter 13. Unusual Data Types
      - Section 13.1. Structures
      - Section 13.2. Pointers
      - Section 13.3. Global Data
      - Additional Resources
      - Key Points
    - Part IV: Statements
      - In this part:
      - Chapter 14. Organizing Straight-Line Code
      - Section 14.1. Statements That Must Be in a Specific Order
      - Section 14.2. Statements Whose Order Doesn't Matter
      - Key Points
      - Chapter 15. Using Conditionals
      - Section 15.1. if Statements
      - Section 15.2. case Statements
      - Key Points
      - Chapter 16. Controlling Loops
      - Section 16.1. Selecting the Kind of Loop
      - Section 16.2. Controlling the Loop
      - Section 16.3. Creating Loops Easily—From the Inside Out
      - Section 16.4. Correspondence Between Loops and Arrays
      - Key Points
      - Chapter 17. Unusual Control Structures
      - Section 17.1. Multiple Returns from a Routine
      - Section 17.2. Recursion
      - Section 17.3. goto
      - Section 17.4. Perspective on Unusual Control Structures
      - Additional Resources
      - Key Points
      - Chapter 18. Table-Driven Methods
      - Section 18.1. General Considerations in Using Table-Driven Methods
      - Section 18.2. Direct Access Tables
      - Section 18.3. Indexed Access Tables
      - Section 18.4. Stair-Step Access Tables
      - Section 18.5. Other Examples of Table Lookups
      - Key Points
      - Chapter 19. General Control Issues
      - Section 19.1. Boolean Expressions
      - Section 19.2. Compound Statements (Blocks)
      - Section 19.3. Null Statements
      - Section 19.4. Taming Dangerously Deep Nesting
      - Section 19.5. A Programming Foundation: Structured Programming
      - Section 19.6. Control Structures and Complexity
      - Key Points
    - Part V: Code Improvements
      - In this part:
      - Chapter 20. The Software-Quality Landscape
      - Section 20.1. Characteristics of Software Quality
      - Section 20.2. Techniques for Improving Software Quality
      - Section 20.3. Relative Effectiveness of Quality Techniques
      - Section 20.4. When to Do Quality Assurance
      - Section 20.5. The General Principle of Software Quality
      - Additional Resources
      - Key Points
      - Chapter 21. Collaborative Construction
      - Section 21.1. Overview of Collaborative Development Practices
      - Section 21.2. Pair Programming
      - Section 21.3. Formal Inspections
      - Section 21.4. Other Kinds of Collaborative Development Practices
      - Comparison of Collaborative Construction Techniques
      - Additional Resources
      - Key Points
      - Chapter 22. Developer Testing
      - Section 22.1. Role of Developer Testing in Software Quality
      - Section 22.2. Recommended Approach to Developer Testing
      - Section 22.3. Bag of Testing Tricks
      - Section 22.4. Typical Errors
      - Section 22.5. Test-Support Tools
      - Section 22.6. Improving Your Testing
      - Section 22.7. Keeping Test Records
      - Additional Resources
      - Key Points
      - Chapter 23. Debugging
      - Section 23.1. Overview of Debugging Issues
      - Section 23.2. Finding a Defect
      - Section 23.3. Fixing a Defect
      - Section 23.4. Psychological Considerations in Debugging
      - Section 23.5. Debugging Tools—Obvious and Not-So-Obvious
      - Additional Resources
      - Key Points
      - Chapter 24. Refactoring
      - Section 24.1. Kinds of Software Evolution
      - Section 24.2. Introduction to Refactoring
      - Section 24.3. Specific Refactorings
      - Section 24.4. Refactoring Safely
      - Section 24.5. Refactoring Strategies
      - Additional Resources
      - Key Points
      - Chapter 25. Code-Tuning Strategies
      - Section 25.1. Performance Overview
      - Section 25.2. Introduction to Code Tuning
      - Section 25.3. Kinds of Fat and Molasses
      - Section 25.4. Measurement
      - Section 25.5. Iteration
      - Section 25.6. Summary of the Approach to Code Tuning
      - Additional Resources
      - Key Points
      - Chapter 26. Code-Tuning Techniques
      - Section 26.1. Logic
      - Section 26.2. Loops
      - Section 26.3. Data Transformations
      - Section 26.4. Expressions
      - Section 26.5. Routines
      - Section 26.6. Recoding in a Low-Level Language
      - Section 26.7. The More Things Change, the More They Stay the Same
      - Additional Resources
      - Key Points
    - Part VI: System Considerations
      - In this part:
      - Chapter 27. How Program Size Affects Construction
      - Section 27.1. Communication and Size
      - Section 27.2. Range of Project Sizes
      - Section 27.3. Effect of Project Size on Errors
      - Section 27.4. Effect of Project Size on Productivity
      - Section 27.5. Effect of Project Size on Development Activities
      - Additional Resources
      - Key Points
      - Chapter 28. Managing Construction
      - Section 28.1. Encouraging Good Coding
      - Section 28.2. Configuration Management
      - Section 28.3. Estimating a Construction Schedule
      - Section 28.5. Treating Programmers as People
      - Section 28.6. Managing Your Manager
      - Key Points
      - Chapter 29. Integration
      - Section 29.1. Importance of the Integration Approach
      - Section 29.2. Integration Frequency—Phased or Incremental?
      - Section 29.3. Incremental Integration Strategies
      - Section 29.4. Daily Build and Smoke Test
      - Additional Resources
      - Key Points
      - Chapter 30. Programming Tools
      - Section 30.1. Design Tools
      - Section 30.2. Source-Code Tools
      - Section 30.3. Executable-Code Tools
      - Section 30.4. Tool-Oriented Environments
      - Section 30.5. Building Your Own Programming Tools
      - Section 30.6. Tool Fantasyland
      - Additional Resources
      - Key Points
    - Part VII: Software Craftsmanship
      - In this part:
      - Chapter 31. Layout and Style
      - Section 31.1. Layout Fundamentals
      - Section 31.2. Layout Techniques
      - Section 31.3. Layout Styles
      - Section 31.4. Laying Out Control Structures
      - Section 31.5. Laying Out Individual Statements
      - Section 31.6. Laying Out Comments
      - Section 31.7. Laying Out Routines
      - Section 31.8. Laying Out Classes
      - Additional Resources
      - Key Points
      - Chapter 32. Self-Documenting Code
      - Section 32.1. External Documentation
      - Section 32.2. Programming Style as Documentation
      - Section 32.3. To Comment or Not to Comment
      - Section 32.4. Keys to Effective Comments
      - Section 32.5. Commenting Techniques
      - Section 32.6. IEEE Standards
      - Additional Resources
      - Key Points
      - Chapter 33. Personal Character
      - Section 33.1. Isn't Personal Character Off the Topic?
      - Section 33.2. Intelligence and Humility
      - Section 33.3. Curiosity
      - Section 33.4. Intellectual Honesty
      - Section 33.5. Communication and Cooperation
      - Section 33.6. Creativity and Discipline
      - Section 33.7. Laziness
      - Section 33.8. Characteristics That Don't Matter As Much As You Might Think
      - Section 33.9. Habits
      - Additional Resources
      - Key Points
      - Chapter 34. Themes in Software Craftsmanship
      - Section 34.1. Conquer Complexity
      - Section 34.2. Pick Your Process
      - Section 34.3. Write Programs for People First, Computers Second
      - Section 34.4. Program into Your Language, Not in It
      - Section 34.5. Focus Your Attention with the Help of Conventions
      - Section 34.6. Program in Terms of the Problem Domain
      - Section 34.7. Watch for Falling Rocks
      - Section 34.8. Iterate, Repeatedly, Again and Again
      - Section 34.9. Thou Shalt Rend Software and Religion Asunder
      - Key Points
      - Chapter 35. Where to Find More Information
      - Section 35.1. Information About Software Construction
      - Section 35.2. Topics Beyond Construction
      - Section 35.3. Periodicals
      - Section 35.4. A Software Developer's Reading Plan
      - Section 35.5. Joining a Professional Organization
  - 10 Minute Guide to Motivating People
    - Lesson 1. What Motivates People?
      - Understanding Motivation
      - Patterns of Motivation
      - Motivations Change
      - Don't Mistake Your Motivation for Theirs
      - Common Motivators
    - Lesson 2. Take Care of the Basics
      - The Importance of Compensation Equity
      - Providing Special Financial Incentives
      - Nobody's Business: Keeping Compensation Private
      - Compensation Envy: Keeping Up with the Joneses
    - Lesson 3. Providing a Great Environment
      - Understanding Motivators and Demotivators
      - Designing an Interesting Workspace
      - Ergonomics Means Safe and Comfortable
    - Lesson 4. Giving Them What They Need to Succeed
      - Training the Troops: From On-the-Job Training to a Degree
      - Providing the Proper Tools
    - Lesson 5. Go Team!
      - Teamwork Today
      - What Makes a Good Team?
      - Does Your Team Come with Baggage?
      - Leadership: It's Essential to a Successful Team
      - Office Team Building
    - Lesson 6. Throw a Party!
      - The Workplace: More Than Work
      - Parties That Motivate
      - Ten Great Party Ideas
    - Lesson 7. Give a Gift
      - Gift Giving as Motivation
      - Shopping for Gifts
      - Free Company Stuff
      - Thanking the Family
    - Lesson 8. Getting Out of the Office
      - Telecommuting: When Work Comes Home
      - Hold That Meeting Off-Site
      - Trips as Perks
    - Lesson 9. Just Go Home!
      - Flex Time: A Hot Trend
      - Job Sharing
      - Taking Leave
    - Lesson 10. Recognizing Achievement
      - The Importance of Recognition
      - Giving Feedback
      - The Art of Giving Performance Reviews
      - Rewarding Excellence
    - Lesson 11. Involving People in Innovation
      - The Foundation for Organizational Innovation
      - Soliciting Ideas
      - Creativity Techniques
      - Acknowledging Contributions
    - Lesson 12. Providing Challenge
      - Understanding Goal Fulfillment
      - Assign an Interesting Project
      - Listen Up!
      - Promoting from Within
    - Lesson 13. Share the Success!
      - Ownership Isn't Just for Owners
      - Share a Piece of the Action
      - Spread the Good News!
      - Now Get Out There and Motivate!
  - 10 Minute Guide to Project Management
    - Lesson 1. So You're Going to Manage a Project?
      - The Elements of a Project
      - Project Planning
      - Implementation
      - Control
      - Possible Project Players
    - Lesson 2. What Makes a Good Project Manager?
      - A Doer, not a Bystander
      - Many Hats All the Time
      - Principles To Steer You
      - Seven Ways to Succeed as a Project Manager
      - Seven Ways to Fail as a Project Manager
    - Lesson 3. What Do You Want to Accomplish?
      - To Lead and to Handle Crises
      - Key Questions
      - Okay, So What are We Attempting to Do?
      - Tasks Versus Outcomes
      - Telling Questions
      - Desired Outcomes that Lend Themselves to Project Management
    - Lesson 4. Laying Out Your Plan
      - No Surprises
      - The Holy Grail and the Golden Fleece
      - From Nothing to Something
    - Lesson 5. Assembling Your Plan
      - The Critical Path for Completing the WBS
      - The Chicken or the Egg?
      - Is Planning Itself a Task?
      - What About Your Hours?
      - Internal Resources Versus External Resources
      - Helping Your Staff When It's Over
      - What Kinds of Tasks Comprise the WBS?
      - Keeping the Big Picture in Mind
      - The Big Picture Versus Endless Minutia
      - From Planning to Monitoring
    - Lesson 6. Keeping Your Eye on the Budget
      - Money Still Doesn't Grow on Trees
      - Experience Pays
      - Traditional Approaches to Budgeting
      - Traditional Measures
      - Systematic Budgeting Problems
    - Lesson 7. Gantt Charts
      - Chart Your Progress
      - Variations on a Theme
      - Embellishments Offer Detail
      - Getting a Project Back on Track
      - Thinking Ahead
    - Lesson 8. PERT/CPM Charts
      - Projects Can Get Complex
      - Enter the PERT and CPM
      - A Short Course
      - What If Things Change?
      - I Feel the Need, the Need for Speed
      - Let's Network
      - Me and My Arrow
      - Don't Fall in Love with the Technology
    - Lesson 9. Reporting Results
      - More Communications Channels Lead to Less Accessibility
      - Incorporate the Thoughts of Others
    - Lesson 10. Choosing Project Management Software
      - With the Click of a Mouse
      - Leave a Good Thing Alone
      - Whose Choice Is It?
      - What's Your Pleasure?
      - Dedicated PM Software
      - How Will You Use PM Software?
    - Lesson 11. A Sampling of Popular Programs
      - Yesterday's News
      - Armed and Online
    - Lesson 12. Multiple Bosses, Multiple Projects, Multiple Headaches
      - Participating on More Than One Project at a Time
      - Complexity Happens
      - A Diffuse Pattern
      - A Tale of Two Offices
      - Extravagance is Not Necessary
      - Reporting to More Than One Boss at a Time
      - Workaholic For Hire
    - Lesson 13. A Construction Mini-Case
      - Helping Construction Site Managers to Be More Effective
      - Let's Assign It to a Project Manager
      - Arm Chair Analysis Versus Onsite Observation
      - Tower of Babel
    - Lesson 14. Learning from Your Experience
      - Life Is Learning, and so Are Projects
      - Master the Software
      - Keep Your Eyes Open
      - Preparing For the Next Project
  - 10 Minute Guide to Leadership, Second Edition
    - Lesson 1. What Is Leadership?
      - Defining Leadership
      - Becoming a Leader
      - The 30-Second Recap
    - Lesson 2. The Traits of a Leader
      - Positive Thought, Positive Talk
      - Vision
      - Building Confidence
      - The 30-Second Recap
    - Lesson 3. Leadership Styles
      - No Two Are Alike
      - Dictatorship
      - The "Almost" Democracy
      - The Partnership
      - Transformational Leadership
      - What Style Is Right for You?
      - The 30-Second Recap
    - Lesson 4. Communicating as a Leader
      - The Importance of Communication
      - Using Language Effectively
      - Nonverbal Communication
      - The 30-Second Recap
    - Lesson 5. Successful Speeches and Presentations
      - The Importance of Public Speaking
      - Speeches
      - Presentations
      - If You Get Nervous
      - The 30-Second Recap
    - Lesson 6. Managing Performance
      - Setting Goals
      - Fostering Teamwork
      - Managing Telecommuters
      - Feedback and Rewards
      - The 30-Second Recap
    - Lesson 7. Improving Your Team
      - Giving Your Team Confidence
      - Delegating
      - Respecting Seniority
      - Advertising Your Group
      - Hiring and Firing
      - The 30-Second Recap
    - Lesson 8. Worst Leadership Mistakes
      - Hey, We're All Best Buddies Here
      - Micromanaging
      - Thin Skin
      - Do as I Say, Not as I Do
      - Don't Forget to Tip
      - My Cousin Vinnie
      - Don't Compete with Your Group
      - The 30-Second Recap
    - Lesson 9. Nonstandard Techniques
      - Encouraging Creativity
      - Using Humor to Get Results
      - Socializing
      - The Power of Persuasion and Manipulation
      - The 30-Second Recap
    - Lesson 10. Avoiding Micromanagement
      - Defining Micromanagement
      - Spotting a Micromanager
      - Curbing Micromanagement
      - Being a Macromanager
      - The 30-Second Recap
    - Lesson 11. Transformational Leadership
      - Defining Transformational Leadership
      - Qualities of the Transformational Leader
      - Working Toward Transformation
      - The 30-Second Recap
    - Lesson 12. Troubleshooting
      - Preventing Problems
      - Recognizing Problems
      - Resolving Problems
      - Conflict Resolution
      - Winning Over a Hostile Staff
      - The 30-Second Recap
    - Lesson 13. Nurturing and Mentoring
      - Growing Your Staff
      - Supporting Education
      - Be a Role Model
      - Mentoring
      - The 30-Second Recap
    - Lesson 14. Women in Leadership
      - What Difference Does Gender Make?
      - Getting There
      - Overcoming Gender Bias
      - Equal Pay
      - Challenges Women Leaders Face
      - If All Else Fails
      - The 30-Second Recap
    - Lesson 15. Young or Minority Leaders
      - Young Leaders and the Challenges They Face
      - Minority Leaders and the Challenges They Face
      - The 30-Second Recap
    - Lesson 16. Where to Find Help
      - Have Your Own Mentor
      - Classes and Seminars
      - Associations
      - The Internet
      - The 30-Second Recap
  - Process Improvement Essentials by James R. Persse, PhD Publisher: O'Reilly Pub Date: September 2006 Print ISBN-10: 0-596-10217-8 Print ISBN-13: 978-0-59-610217-3 Pages: 350
    - Part I: Process and Process Improvement
      - Chapter 1. Introduction
        Section 1.1. A Path of Quality
        Section 1.2. The Innovation/Chaos Paradox
        Section 1.3. Marshal Extra Forces If...
        Section 1.4. Moving Forward
        Section 1.5. Summary
      - Chapter 2. The Case for Process
        Section 2.1. An American Success Story
        Section 2.2. The Conscious Organization
        Section 2.3. Some Number Stories
        Section 2.4. Six Common Myths
        Section 2.5. Benefits of Process
        Section 2.6. Summary
      - Chapter 3. Establishing Your Process Program
        Section 3.1. Using IDEAL
        Section 3.2. Establishing Executive Sponsorship
        Section 3.3. Aligning with Business Objectives
        Section 3.4. Identifying Improvement Opportunities
        Section 3.5. Establishing the Process Team
        Section 3.6. Choose Your Model (or Not)
        Section 3.7. Developing Process Program Components
        Section 3.8. Training
        Section 3.9. Program Rollout
        Section 3.10. Institutionalization
        Section 3.11. Helpful Change Agent Skills
        Section 3.12. Summary
      - Chapter 4. Sustaining Process Improvement
        Section 4.1. 1. Remember What You Do
        Section 4.2. 2. Weld Business Success to Program Success
        Section 4.3. 3. Participate
        Section 4.4. 4. Training
        Section 4.5. 5. Support Compliance
        Section 4.6. 6. Active Feedback Mechanisms
        Section 4.7. 7. Promote Performance Incentives
        Section 4.8. 8. Celebrate Success
        Section 4.9. 9. Public Announcements
        Section 4.10. 10. Measure, Measure
        Section 4.11. 11. Periodic Reassessment
        Section 4.12. 12. Appreciate the Journey
        Section 4.13. Summary
    - Part II: Three Major Process Improvement Standards
      - Chapter 5. ISO 9001:2000
        Section 5.1. A Brief History of ISO 9001:2000
        Section 5.2. ISO 9001 Ownership
        Section 5.3. The Structure and Design of ISO 9001:2000
        Section 5.4. ISO 9000: Sections 1 Through 3
        Section 5.5. Section 4. Quality Management System
        Section 5.6. Section 5. Management Responsibility
        Section 5.7. Section 6. Resource Management
        Section 5.8. Section 7. Product Realization
        Section 5.9. Section 8. Measurement, Analysis, and Improvement
        Section 5.10. For a Deeper Look
        Section 5.11. Summary
      - Chapter 6. The Capability Maturity Model Integration (for Development)
        Section 6.1. A Brief History of CMMI
        Section 6.2. CMMI Ownership
        Section 6.3. Technology Disciplines Covered Under CMMI
        Section 6.4. CMMI-Dev Structure and Design
        Section 6.5. Generic Goals of CMMI
        Section 6.6. The Process Areas of CMMI
        Section 6.7. Project Management Process Areas
        Section 6.8. Engineering Process Areas
        Section 6.9. Support Process Areas
        Section 6.10. Process Management Process Areas
        Section 6.11. Implementing CMMI
        Section 6.12. For a Deeper Look
        Section 6.13. Summary
      - Chapter 7. Six Sigma
        Section 7.1. A Brief History of Six Sigma
        Section 7.2. Six Sigma Ownership
        Section 7.3. Six Sigma Structure and Design
        Section 7.4. Define
        Section 7.5. Measure
        Section 7.6. Analyze
        Section 7.7. Improve
        Section 7.8. Control
        Section 7.9. The Six Sigma Team
        Section 7.10. For a Deeper Look
        Section 7.11. Summary
      - Chapter 8. Considerations for Adoption
        Section 8.1.
        Section 8.2. Summary
- Languages
  - C#
    - Core C# and .NET
      - Part I. Fundamentals of C# Programming and Introduction to .NET
        Chapter 1. Introduction to .NET and C#
        Section 1.1. Overview of the .NET Framework
        Section 1.2. Common Language Runtime
        Section 1.3. Framework Class Library
        Section 1.4. Working with the .NET Framework and SDK
        Section 1.5. Understanding the C# Compiler
        Section 1.6. Summary
        Section 1.7. Test Your Understanding
        Chapter 2. C# Language Fundamentals
        Section 2.1. The Layout of a C# Program
        Section 2.2. Primitives
        Section 2.3. Operators: Arithmetic, Logical, and Conditional
        Section 2.4. Loops
        Section 2.5. C# Preprocessing Directives
        Section 2.6. Strings
        Section 2.7. Enumerated Types
        Section 2.8. Arrays
        Section 2.9. Reference and Value Types
        Section 2.10. Summary
        Section 2.11. Test Your Understanding
        Chapter 3. Class Design in C#
        Section 3.1. Introduction to a C# Class
        Section 3.2. Defining a Class
        Section 3.3. Overview of Class Members
        Section 3.4. Constants, Fields, and Properties
        Section 3.5. Methods
        Section 3.6. Constructors
        Section 3.7. Delegates and Events
        Section 3.8. Operator Overloading
        Section 3.9. Interfaces
        Section 3.10. Generics
        Section 3.11. Structures
        Section 3.12. Structure Versus Class
        Section 3.13. Summary
        Section 3.14. Test Your Understanding
        Chapter 4. Working with Objects in C#
        Section 4.1. Object Creation
        Section 4.2. Exception Handling
        Section 4.3. Implementing System.Object Methods in a Custom Class
        Section 4.4. Working with .NET Collection Classes and Interfaces
        Section 4.5. Object Serialization
        Section 4.6. Object Life Cycle Management
        Section 4.7. Summary
        Section 4.8. Test Your Understanding
      - Part II. Creating Applications Using the .NET Framework Class Library
        Chapter 5. C# Text Manipulation and File I/O
        Section 5.1. Characters and Unicode
        Section 5.2. The String Class
        Section 5.3. Comparing Strings
        Section 5.4. Searching, Modifying, and Encoding a String's Content
        Section 5.5. StringBuilder
        Section 5.6. Formatting Numeric and DateTime Values
        Section 5.7. Regular Expressions
        Section 5.8. System.IO: Classes to Read and Write Streams of Data
        Section 5.9. System.IO: Directories and Files
        Section 5.10. Summary
        Section 5.11. Test Your Understanding
        Chapter 6. Building Windows Forms Applications
        Section 6.1. Programming a Windows Form
        Section 6.2. Windows.Forms Control Classes
        Section 6.3. The Form Class
        Section 6.4. Working with Menus
        Section 6.5. Adding Help to a Form
        Section 6.6. Forms Inheritance
        Section 6.7. Summary
        Section 6.8. Test Your Understanding
        Chapter 7. Windows Forms Controls
        Section 7.1. A Survey of .NET Windows Forms Controls
        Section 7.2. Button Classes, Group Box, Panel, and Label
        Section 7.3. PictureBox and TextBox Controls
        Section 7.4. ListBox, CheckedListBox, and ComboBox Classes
        Section 7.5. The ListView and TreeView Classes
        Section 7.6. The ProgressBar, Timer, and StatusStrip Classes
        Section 7.7. Building Custom Controls
        Section 7.8. Using Drag and Drop with Controls
        Section 7.9. Using Resources
        Section 7.10. Summary
        Section 7.11. Test Your Understanding
        Chapter 8. .NET Graphics Using GDI+
        Section 8.1. GDI+ Overview
        Section 8.2. Using the Graphics Object
        Section 8.3. Images
        Section 8.4. Summary
        Section 8.4. Test Your Understanding
        Chapter 9. Fonts, Text, and Printing
        Section 9.1. Fonts
        Section 9.2. Drawing Text Strings
        Section 9.3. Printing
        Section 9.4. Summary
        Section 9.5. Test Your Understanding
        Chapter 10. Working with XML in .NET
        Section 10.1. Working with XML
        Section 10.2. Techniques for Reading XML Data
        Section 10.3. Techniques for Writing XML Data
        Section 10.4. Using XPath to Search XML
        Section 10.5. Summary
        Section 10.6. Test Your Understanding
        Chapter 11. ADO.NET
        Section 11.1. Overview of the ADO.NET Architecture
        Section 11.2. Data Access Models: Connected and Disconnected
        Section 11.3. ADO.NET Connected Model
        Section 11.4. DataSets, DataTables, and the Disconnected Model
        Section 11.5. XML and ADO.NET
        Section 11.6. Summary
        Section 11.7. Test Your Understanding
        Chapter 12. Data Binding with Windows Forms Controls
        Section 12.1. Overview of Data Binding
        Section 12.2. Using Simple and Complex Data Binding in an Application
        Section 12.3. The DataGridView Class
        Section 12.4. Summary
        Section 12.4. Test Your Understanding
      - Part III. Advanced Use of C# and the .NET Framework
        Chapter 13. Asynchronous Programming and Multithreading
        Section 13.1. What Is a Thread?
        Section 13.2. Asynchronous Programming
        Section 13.3. Working Directly with Threads
        Section 13.4. Thread Synchronization
        Section 13.5. Summary
        Section 13.5. Test Your Understanding
        Chapter 14. Creating Distributed Applications with Remoting
        Section 14.1. Application Domains
        Section 14.2. Remoting
        Section 14.3. Leasing and Sponsorship
        Section 14.4. Summary
        Section 14.5. Test Your Understanding
        Chapter 15. Code Refinement, Security, and Deployment
        Section 15.1. Following .NET Code Design Guidelines
        Section 15.2. Strongly Named Assemblies
        Section 15.3. Security
        Section 15.4. Application Deployment Considerations
        Section 15.5. Summary
        Section 15.6. Test Your Understanding
      - Part Programming for the Internet
        Chapter 16. ASP.NET Web Forms and Controls
        Section 16.1. Client-Server Interaction over the Internet
        Section 16.2. Web Forms Controls
        Section 16.3. Data Binding and Data Source Controls
        Section 16.4. Validation Controls
        Section 16.5. Master and Content Pages
        Section 16.6. Building and Using Custom Web Controls
        Section 16.7. Selecting a Web Control to Display Data
        Section 16.8. Summary
        Section 16.9. Test Your Understanding
        Chapter 17. The Asp.Net Application Environment
        Section 17.1. HTTP Request and Response Classes
        Section 17.2. ASP.NET and Configuration Files
        Section 17.3. ASP.NET Application Security
        Section 17.4. Maintaining State
        Section 17.5. Caching
        Section 17.6. Creating a Web Client with WebRequest and WebResponse
        Section 17.7. HTTP Pipeline
        Section 17.8. Summary
        Section 17.9. Test Your Understanding
        Chapter 18. XML Web Services
        Section 18.1. Introduction to Web Services
        Section 18.2. Building an XML Web Service
        Section 18.3. Building an XML Web Service Client
        Section 18.4. Understanding WSDL and SOAP
        Section 18.5. Using Web Services with Complex Data Types
        Section 18.6. Web Services Performance
        Section 18.7. Summary
        Section 18.8. Test Your Understanding
        Appendix A. Features Specific to .NET 2.0 and C# 2.0
        Appendix B. DataGridView Events and Delegates
        Answers to Chapter Exercises
    - Microsoft®C# Programming for the absolute beginner by Andy Harris Publisher: Premier Press Pub Date: 2002 Print ISBN-10: 1-931841-16-0 Print ISBN-13: 978-1-931841-16-0 Pages: 512
      - Chapter 1. Basic Input and Output: A Mini Adventure
        Project: The Mini Adventure
        Reviewing Basic C# Concepts
        Saying "Hello, World!"
        Moving from Code to a Program
        Compiling Your Program
        Looking for Bugs
        Getting Input from the User
        Incorporating a Variable in Output
        Combining String Values
        Launching the Mini Adventure
        Summary
      - Chapter 2. Branching and Operators: The Math Game
        The Math Game
        Using Numeric Variables
        Converting Variables
        Creating a Branch in Program Logic
        Working with The Switch Statement
        Creating a Random Number
        Creating the Math Game
        Summary
      - Chapter 3. Loops and Strings: The Pig Latin Program
        Project: The Pig Latin Program
        Investigating The String Object
        Using a For Loop
        Varying the For Loop's Behavior
        Using a While Loop
        Planning Your Program with the STAIR Process
        Applying STAIR to the Pig Latin Program
        Writing the Pig Latin Program
        Summary
      - Chapter 4. Objects and Encapsulation: The Critter Program
        Introducing the Critter Program
        Creating Methods to Reuse Code
        Creating a Menu
        Creating a New Object with the CritterName Program
        Adding a Method
        Creating the talk() Method for the CritterTalk Program
        Changing the Menu to Use the talk() Method
        Creating a Property in the CritterProp Program
        Making the Critter More Lifelike
        Summary
      - Chapter 5. Constructors, Inheritance, and Polymorphism: The Snowball Fight
        Introducing the Snowball Fight
        Inheritance and Encapsulation
        Creating a Constructor
        Overloading Constructors
        Using Inheritance to Make New Classes
        Improving an Existing Class
        Using Polymorphism to Alter a Class's Behavior
        Creating the Snowball Fight
        Summary
      - Chapter 6. Creating a Windows Program: The Visual Critter
        Introducing the Visual Critter
        Creating a Windows-Style Program with a GUI
        Examining the Code of a Windows Program
        Creating an Interactive Program
        Allowing for Multiple Selections
        Working with Images and Scroll Bars
        Revisiting the Visual Critter
        Summary
      - Chapter 7. Timers and Animation: The Lunar Lander
        Introducing the Lunar Lander
        Reading Values from the Keyboard
        Animating Images
        Using a Timer to Automate Animation
        Adding Motion
        Detecting Collisions between Objects
        Bouncing the Ball off the Sides
        Checking for Collisions
        Extracting a Rectangle from a Component
        Getting More from the MessageBox Object
        Coding the Lunar Lander
        Summary
      - Chapter 8. Arrays: The Soccer Game
        The Soccer Game
        Introducing Arrays
        Working with Arrays
        Designing the Soccer Game
        Designing Programs by Hand
        Building the Soccer Program
        Setting Up the Players
        Setting Up the Opponents
        Setting Up the Goalies
        Responding to Player Clicks
        Handling Good Shots
        Handling Bad Shots
        Setting a New Current Player
        Handling the Passage of Time
        Updating the Score
        Summary
      - Chapter 9. File Handling: The Adventure Kit
        Introducing the Adventure Kit
        Reading and Writing Text Files
        Creating Menus
        Using Dialog Boxes to Enhance Your Programs
        Storing Entire Objects with Serialization
        Returning to the Adventure Kit Program
        Summary
      - Chapter 10. Chapter Basic XML: The Quiz Maker
        Introducing the Quiz Maker Game
        Investigating XML
        Reading an Existing XML Document
        Writing New Values to an XML Document
        Examining the Quizzer Program
        Summary
      - Chapter 11. Databases and ADO.NET: The Spy Database
        Introducing the SpyMaster Program
        Creating a Simple Database
        Using Queries to Modify Data Results
        Working with Relational Databases
        Working with Other Databases
        Creating the SpyMaster Database
        Summary
    - Programming C#, 4th Edition by Jesse Liberty Publisher: O'Reilly Pub Date: February 2005 ISBN: 0-596-00699-3 Pages: 666
      - Preface
        About This Book
        What You Need To Use This Book
        How the Book Is Organized
        Who This Book Is For
        C# 2.0 Versus C# 1.1
        C# Versus Visual Basic .NET
        C# Versus Java
        C# Versus C and C++
        Conventions Used in This Book
        Support
        We'd Like to Hear from You
        Safari Enabled
        Acknowledgments
      - Part I: The C# Language
        Chapter 1. C# and the .NET Framework
        Section 1.1. The .NET Platform
        Section 1.2. The .NET Framework
        Section 1.3. Compilation and the MSIL
        Section 1.4. The C# Language
        Chapter 2. Getting Started: "Hello World"
        Section 2.1. Classes, Objects, and Types
        Section 2.2. Developing "Hello World"
        Section 2.3. Using the Visual Studio .NET Debugger
        Chapter 3. C# Language Fundamentals
        Section 3.1. Types
        Section 3.2. Variables and Constants
        Section 3.3. Expressions
        Section 3.4. Whitespace
        Section 3.5. Statements
        Section 3.6. Operators
        Section 3.7. Preprocessor Directives
        Chapter 4. Classes and Objects
        Section 4.1. Defining Classes
        Section 4.2. Creating Objects
        Section 4.3. Using Static Members
        Section 4.4. Destroying Objects
        Section 4.5. Passing Parameters
        Section 4.6. Overloading Methods and Constructors
        Section 4.7. Encapsulating Data with Properties
        Section 4.8. readonly Fields
        Chapter 5. Inheritance and Polymorphism
        Section 5.1. Specialization and Generalization
        Section 5.2. Inheritance
        Section 5.3. Polymorphism
        Section 5.4. Abstract Classes
        Section 5.5. The Root of All Classes: Object
        Section 5.6. Boxing and Unboxing Types
        Section 5.7. Nesting Classes
        Chapter 6. Operator Overloading
        Section 6.1. Using the operator Keyword
        Section 6.2. Supporting Other .NET Languages
        Section 6.3. Creating Useful Operators
        Section 6.4. Logical Pairs
        Section 6.5. The Equality Operator
        Section 6.6. Conversion Operators
        Chapter 7. Structs
        Section 7.1. Defining Structs
        Section 7.2. Creating Structs
        Chapter 8. Interfaces
        Section 8.1. Defining and Implementing an Interface
        Section 8.2. Accessing Interface Methods
        Section 8.3. Overriding Interface Implementations
        Section 8.4. Explicit Interface Implementation
        Chapter 9. Arrays, Indexers, and Collections
        Section 9.1. Arrays
        Section 9.2. The foreach Statement
        Section 9.3. Indexers
        Section 9.4. Collection Interfaces
        Section 9.5. Constraints
        Section 9.6. List<T>
        Section 9.7. Queues
        Section 9.8. Stacks
        Section 9.9. Dictionaries
        Chapter 10. Strings and Regular Expressions
        Section 10.1. Strings
        Section 10.2. Regular Expressions
        Chapter 11. Handling Exceptions
        Section 11.1. Throwing and Catching Exceptions
        Section 11.2. Exception Objects
        Section 11.3. Custom Exceptions
        Section 11.4. Rethrowing Exceptions
        Chapter 12. Delegates and Events
        Section 12.1. Delegates
        Section 12.2. Multicasting
        Section 12.3. Events
        Section 12.4. Using Anonymous Methods
        Section 12.5. Retrieving Values from Multicast Delegates
      - Part II: Programming with C#
        Chapter 13. Building Windows Applications
        Section 13.1. Creating a Simple Windows Form
        Section 13.2. Creating a Windows Forms Application
        Section 13.3. XML Documentation Comments
        Chapter 14. Accessing Data with ADO.NET
        Section 14.1. Relational Databases and SQL
        Section 14.2. The ADO.NET Object Model
        Section 14.3. Getting Started with ADO.NET
        Section 14.4. Using OLE DB Managed Providers
        Section 14.5. Working with Data-Bound Controls
        Chapter 15. Programming ASP.NET Applications and Web Services
        Section 15.1. Understanding Web Forms
        Section 15.2. Creating a Web Form
        Section 15.3. Adding Controls
        Section 15.4. Data Binding
        Section 15.5. Web Services
        Section 15.6. SOAP, WSDL, and Discovery
        Section 15.7. Building a Web Service
        Section 15.8. Creating the Proxy
        Chapter 16. Putting It All Together
        Section 16.1. The Overall Design
        Section 16.2. Creating the Web Services Client
        Section 16.3. Displaying the Output
        Section 16.4. Searching by Category
      - Part III: The CLR and the .NET Framework
        Chapter 17. Assemblies and Versioning
        Section 17.1. PE Files
        Section 17.2. Metadata
        Section 17.3. Security Boundary
        Section 17.4. Manifests
        Section 17.5. Multimodule Assemblies
        Section 17.6. Private Assemblies
        Section 17.7. Shared Assemblies
        Chapter 18. Attributes and Reflection
        Section 18.1. Attributes
        Section 18.2. Reflection
        Chapter 19. Marshaling and Remoting
        Section 19.1. Application Domains
        Section 19.2. Context
        Section 19.3. Remoting
        Chapter 20. Threads and Synchronization
        Section 20.1. Threads
        Section 20.2. Synchronization
        Section 20.3. Race Conditions and Deadlocks
        Chapter 21. Streams
        Section 21.1. Files and Directories
        Section 21.2. Reading and Writing Data
        Section 21.3. Asynchronous I/O
        Section 21.4. Network I/O
        Section 21.5. Web Streams
        Section 21.6. Serialization
        Section 21.7. Isolated Storage
        Chapter 22. Programming .NET and COM
        Section 22.1. Importing ActiveX Controls
        Section 22.2. Importing COM Components
        Section 22.3. Exporting .NET Components
        Section 22.4. P/Invoke
        Section 22.5. Pointers
      - Appendix A. C# Keywords
    - Essential C# 2.0 by Mark Michaelis Publisher: Addison Wesley Professional Pub Date: July 13, 2006 Print ISBN-10: 0-321-15077-5 Print ISBN-13: 978-0-321-15077-6 Pages: 768
      - Chapter 1. Introducing C#
        Hello, World
        C# Syntax Fundamentals
        Working with Variables
        Console Input and Output
        Comments
        Common Intermediate Language and ILDASM
        Summary
      - Chapter 2. Data Types
        Fundamental Numeric Types
        More Fundamental Types
        null and void
        Categories of Types
        Nullable Modifier
        Conversions between Data Types
        Arrays
        Summary
      - Chapter 3. Operators and Control Flow
        Operators
        Introducing Flow Control
        Code Blocks ({})
        Scope
        Boolean Expressions
        Bitwise Operators (<<, >>, |, &, ^, ~)
        Control Flow Statements, Continued
        Jump Statements
        C# Preprocessor Directives
        Summary
      - Chapter 4. Methods and Parameters
        Calling a Method
        Declaring a Method
        The using Directive
        Returns and Parameters on Main()
        Parameters
        Recursion
        Method Overloading
        Basic Error Handling with Exceptions
        Summary
      - Chapter 5. Classes
        Defining and Instantiating a Class
        Instance Fields
        Instance Methods
        Using the this Keyword
        Access Modifiers
        Constructors
        Static
        const and readonly Modifiers
        Properties
        Nested Classes
        Partial Classes
        Summary
      - Chapter 6. Inheritance
        Derivation
        Overriding the Base Class
        Abstract Classes
        Everything Ultimately Derives from System.Object
        Verifying the Underlying Type with the is Operator
        Conversion Using the as Operator
        Summary
      - Chapter 7. Interfaces
        Introducing Interfaces
        Polymorphism through Interfaces
        Interface Implementation
        Casting between the Implementing Class and Its Interfaces
        Multiple Interface Inheritance
        Implementing Multiple Inheritance via Interfaces
        Versioning
        Interfaces Compared with Classes
        Summary
      - Chapter 8. Value Types
        Structs
        Boxing
        Enums
        Summary
      - Chapter 9. Well-Formed Types
        Overriding object Members
        Operator Overloading
        Defining Namespaces
        XML Comments
        Garbage Collection
        Resource Cleanup
        Summary
      - Chapter 10. Exception Handling
        Multiple Exception Types
        Catching Exceptions
        General Catch Block
        Guidelines for Exception Handling
        Defining Custom Exceptions
        Summary
      - Chapter 11. Generics
        C# without Generics
        Introducing Generic Types
        Constraints
        Generic Methods
        Generic Internals
        Summary
      - Chapter 12. Collections
        Primary Collection Classes
        Introducing Collection Class Interfaces
        Providing an Index Operator
        Returning Null or an Empty Collection
        Iterators
        Summary
      - Chapter 13. Delegates and Events
        Method Pointers
        Multicast Delegates and the Observer Pattern
        Events
        Summary
      - Chapter 14. Reflection and Attributes
        Reflection
        Attributes
        Summary
      - Chapter 15. Multithreading
        Running and Controlling a Separate Thread
        Passing Parameters to Threads
        Thread Pooling
        Unhandled Exceptions
        Synchronization
        Summary
      - Chapter 16. Multithreading Patterns
        Asynchronous Results Pattern
        Background Worker Pattern
        Windows Forms
        Summary
      - Chapter 17. Platform Interoperability and Unsafe Code
        Platform Invoke
        Pointers and Addresses
        Summary
      - Chapter 18. The Common Language Infrastructure
        Defining the Common Language Infrastructure (CLI)
        CLI Implementations
        C# Compilation to Machine Code
        Runtime
        Application Domains
        Assemblies, Manifests, and Modules
        Common Intermediate Language (CIL)
        Common Type System (CTS)
        Common Language Specification (CLS)
        Base Class Library (BCL)
        Metadata
        Summary
      - Appendix A. Downloading and Installing the C# Compiler and the CLI Platform
        Microsoft's .NET
        Mono
      - Appendix B. Complete Source Code Listings
        Chapters 3 and 4
        Chapter 9
        Chapter 12
        Chapter 14
        Chapter 17
      - Appendix C. C# 2.0 Topics
    - Programming Microsoft® Visual C#® 2005: The Language by Donis Marshall Publisher: Microsoft Press Pub Date: December 20, 2005 Print ISBN-10: 0-7356-2181-0 Print ISBN-13: 978-0-7356-2181-7 Pages: 704
      - Part I: Core Language
        Chapter 1. Introduction to Visual C# Programming
        Language Origin
        C# Core Language Features
        Sample C# Program
        Namespaces
        Main Entry Point
        Local Variables
        Nullable Types
        Expressions
        Selection Statements
        Iterative Statements
        Classes
        Chapter 2. Types
        Classes
        Structures
        Enumeration
        Identity versus Equivalence
        Class Refinement
        Chapter 3. Inheritance
        Inheritance Example
        System.Object
        Employee Class
        Implementing Inheritance
        Overriding
        New Modifier
        Abstract
        Sealed
        Constructors and Destructors
        Interfaces
        Polymorphism
        Casting
        Attribute Inheritance
        Visual Studio .NET 2005
      - Part II: Core Skills
        Chapter 4. Introduction to Visual Studio 2005
        Integrated Development Environment
        Class Hierarchies
        Code Editor
        Code Snippets
        Refactoring
        Building and Deployment
        MSBuild
        Click Once Deployment
        Arrays and Collections
        Chapter 5. Arrays and Collections
        Arrays
        Collections
        Generics
        Chapter 6. Generics
        Generic Types
        Generic Methods
        Constraints
        Casting
        Inheritance
        Static Members
        Enumerators
        Chapter 7. Iterators
        Enumerable Objects
        Generic Enumerators
        Iterators
        Delegates and Events
      - Part III: More C# Language
        Chapter 8. Delegates and Events
        Delegates
        Anonymous Methods
        Events
        Exception Handling
        Chapter 9. Exception Handling
        Exception Example
        Common Exception Model
        Structured Exception Handling
        System.Exception
        Remote Exceptions
        Unhandled Exceptions
        Managing Exceptions in Visual Studio
        Metadata and Reflections
      - Part IV: Debugging
        Chapter 10. Metadata and Reflection
        Metadata
        Reflection
        Reflection and Generics
        MSIL
        Chapter 11. MSIL Programming
        "Hello World" Application
        Evaluation Stack
        MSIL in Depth
        Complex Tasks
        Branching
        Arrays
        Arithmetic Instructions
        Process Execution
        Debugging with Visual Studio 2005
        Chapter 12. Debugging with Visual Studio 2005
        Debugging Overview
        Advanced Debugging
        Chapter 13. Advanced Debugging
        DebuggableAttribute Attribute
        Debuggers
        Just-In-Time (JIT) Debugging
        Managed Debugger
        WinDbg
        Son of Strike (SOS)
        Dumps
        Memory Management
        Threads
        Exceptions
        Symbols
        Memory Management
      - Part V: Advanced Concepts
        Chapter 14. Memory Management
        Unmanaged Resources
        Finalizers
        IDisposable.Dispose
        Weak Reference
        GC Class
        Nonsecure Code
        Chapter 15. Unsafe Code
        Unsafe Keyword
        Summary
      - Operator Overloading
        Mathematical and Logical Operators
        Conversion Operators
        Practical Example
        Operator Overloading Internals
  - ASP.NET
    - Programming ASP.NET, 3rd Edition by Dan Hurwitz, Jesse Liberty Publisher: O'Reilly Pub Date: October 2005 ISBN: 0-596-00916-X Pages: 956
      - Chapter 1. ASP.NET 2.0
        Section 1.1. .NET Framework 2.0
        Section 1.2. ASP.NET 2.0
        Section 1.3. New Features
        Section 1.4. On to VS2005
      - Chapter 2. Visual Studio 2005
        Section 2.1. Start Page
        Section 2.2. Projects and Solutions
        Section 2.3. The Integrated Development Environment (IDE)
      - Chapter 3. Controls: Fundamental Concepts
        Section 3.1. Events
        Section 3.2. ASP.NET Server Controls
        Section 3.3. HTML Server Controls
        Section 3.4. Client-Side Processing
      - Chapter 4. Basic Controls
        Section 4.1. The Basics
        Section 4.2. Label Control
        Section 4.3. TextBox Control
        Section 4.4. HiddenField Control
        Section 4.5. Button Controls
        Section 4.6. HyperLink Control
        Section 4.7. Selecting Values
        Section 4.8. Selecting from a List
        Section 4.9. Tables
        Section 4.10. Panel Control
        Section 4.11. Images
      - Chapter 5. Advanced Controls
        Section 5.1. MultiView and View Controls
        Section 5.2. Wizard Control
        Section 5.3. FileUpload Control
        Section 5.4. AdRotator Control
        Section 5.5. Calendar
      - Chapter 6. Web Site Fundamentals
        Section 6.1. The Page
        Section 6.2. Code-Behind
        Section 6.3. Moving to Another Page
        Section 6.4. State
        Section 6.5. Lifecycle
        Section 6.6. Directives
      - Chapter 7. Tracing, Debugging, and Error Handling
        Section 7.1. Creating the Sample Application
        Section 7.2. Tracing
        Section 7.3. Debugging
        Section 7.4. Error Handling
      - Chapter 8. Validation
        Section 8.1. The RequiredFieldValidator
        Section 8.2. The Summary Control
        Section 8.3. The Compare Validator
        Section 8.4. Range Checking
        Section 8.5. Regular Expressions
        Section 8.6. Custom Validation
        Section 8.7. Validation Groups
      - Chapter 9. Web Data Access
        Section 9.1. Getting Data from a Database
        Section 9.2. Data Source Controls
        Section 9.3. GridView Control
        Section 9.4. Multiuser Updates
        Section 9.5. DataList Control
        Section 9.6. Repeater Control
        Section 9.7. DetailsView Control: Examining One Record at a Time
        Section 9.8. FormView Control: Examining Single Records as Master/Detail
      - Chapter 10. ADO.NET
        Section 10.1. The ADO.NET Object Model
        Section 10.2. Getting Started with ADO.NET
        Section 10.3. Creating Data Objects by Hand
        Section 10.4. Stored Procedures
        Section 10.5. Updating with SQL and ADO.NET
        Section 10.6. Updating Data with Transactions
        Section 10.7. Binding to Business Objects
      - Chapter 11. Forms-Based Security
        Section 11.1. Authentication
        Section 11.2. Forms-Based Authentication in Detail
        Section 11.3. Add Roles to ASP.NET Accounts
      - Chapter 12. Master Pages and Navigation
        Section 12.1. Master Pages
        Section 12.2. Navigation
        Section 12.3. Filtering Based on Security
      - Chapter 13. Personalization
        Section 13.1. Creating Personalized Web Sites
        Section 13.2. Personalizing with Complex Types
        Section 13.3. Anonymous Personalization
        Section 13.4. Themes and Skins
        Section 13.5. Web Parts
        Section 13.6. Enabling Editing and Layout Changes
      - Chapter 14. Custom and User Controls
        Section 14.1. User Controls
        Section 14.2. Custom Controls
      - Chapter 15. Creating Web Services
        Section 15.1. How Web Services Work
        Section 15.2. Protocols and Standards
        Section 15.3. Creating a Simple Web Service
        Section 15.4. WebService Directive
        Section 15.5. Deriving from the WebService Class
        Section 15.6. Application State via HttpContext
        Section 15.7. WebServiceBinding Attribute
        Section 15.8. WebMethod Attribute
        Section 15.9. WebService Attribute
        Section 15.10. Data Types
        Section 15.11. StockTickerComplete
        Section 15.12. Creating Discovery Documents
        Section 15.13. Deployment
      - Chapter 16. Consuming Web Services
        Section 16.1. Discovery
        Section 16.2. Creating the Client with VS2005
        Section 16.3. Creating the Client Manually
        Section 16.4. Using Asynchronous Method Calls
      - Chapter 17. Caching and Performance
        Section 17.1. Types of Caching
        Section 17.2. Data Caching
        Section 17.3. Output Caching
        Section 17.4. Object Caching
        Section 17.5. The HttpCachePolicy Class
        Section 17.6. Performance
        Section 17.7. Benchmarking and Profiling
      - Chapter 18. Application Logic and Configuration
        Section 18.1. Internet Information Server (IIS)
        Section 18.2. Understanding Web Applications
        Section 18.3. Application-Wide Logic
        Section 18.4. Configuring the Application
      - Chapter 19. Deployment
        Section 19.1. Assemblies
        Section 19.2. Local Deployment
        Section 19.3. Global Deployment
        Section 19.4. Windows Installer
      - Appendix A. Keyboard Shortcuts
      - Appendix B. Relational Database Technology: A Crash Course
        Section B.1. Tables, Records, and Columns
        Section B.2. Table Design
        Section B.3. SQL
    - ASP.NET 2.0 Unleashed by Stephen Walther Publisher: Sams Pub Date: June 06, 2006 Print ISBN-10: 0-672-32823-2 Print ISBN-13: 978-0-672-32823-7 Pages: 1992
      - Part I: Building ASP.NET Pages
        Chapter 1. Overview of the ASP.NET Framework
        ASP.NET and the .NET Framework
        Understanding ASP.NET Controls
        Understanding ASP.NET Pages
        Installing the ASP.NET Framework
        Summary
        Chapter 2. Using the Standard Controls
        Displaying Information
        Accepting User Input
        Submitting Form Data
        Displaying Images
        Using the Panel Control
        Using the HyperLink Control
        Summary
        Chapter 3. Using the Validation Controls
        Overview of the Validation Controls
        Using the RequiredFieldValidator Control
        Using the RangeValidator Control
        Using the CompareValidator Control
        Using the RegularExpressionValidator Control
        Using the CustomValidator Control
        Using the ValidationSummary Control
        Creating Custom Validation Controls
        Summary
        Chapter 4. Using the Rich Controls
        Accepting File Uploads
        Displaying a Calendar
        Displaying Advertisements
        Displaying Different Page Views
        Displaying a Wizard
        Summary
      - Part II: Designing ASP.NET Websites
        Chapter 5. Designing Websites with Master Pages
        Creating Master Pages
        Modifying Master Page Content
        Loading Master Pages Dynamically
        Summary
        Chapter 6. Designing Websites with Themes
        Creating Themes
        Adding Skins to Themes
        Adding Cascading Style Sheets to Themes
        Creating Global Themes
        Applying Themes Dynamically
        Summary
        Chapter 7. Creating Custom Controls with User Controls
        Creating User Controls
        AJAX and User Controls
        Dynamically Loading User Controls
        Summary
      - Part III: Performing Data Access
        Chapter 8. Overview of Data Access
        Using DataBound Controls
        Using DataSource Controls
        Using Programmatic DataBinding
        Understanding Templates and DataBinding Expressions
        Overview of SQL Server 2005 Express
        Sample Database-Driven Web Application
        Summary
        Chapter 9. Using the SqlDataSource Control
        Creating Database Connections
        Executing Database Commands
        Using ASP.NET Parameters with the SqlDataSource Control
        Programmatically Executing SqlDataSource Commands
        Caching Database Data with the SqlDataSource Control
        Summary
        Chapter 10. Using List Controls
        Overview of the List Controls
        Working with the DropDownList Control
        Working with the RadioButtonList Control
        Working with the ListBox Control
        Working with the CheckBoxList Control
        Working with the BulletedList Control
        Creating a Custom List Control
        Summary
        Chapter 11. Using the GridView Control
        GridView Control Fundamentals
        Using Fields with the GridView Control
        Working with GridView Control Events
        Extending the GridView Control
        Summary
        Chapter 12. Using the DetailsView and FormView Controls
        Using the DetailsView Control
        Using the FormView Control
        Summary
        Chapter 13. Using the Repeater and DataList Controls
        Using the Repeater Control
        Using the DataList Control
        Summary
      - Part IV: Building Components
        Chapter 14. Building Components
        Building Basic Components
        Building Component Libraries
        Architectural Considerations
        Summary
        Chapter 15. Using the ObjectDataSource Control
        Representing Objects with the ObjectDataSource Control
        Using Parameters with the ObjectDataSource Control
        Paging, Sorting, and Filtering Data with the ObjectDataSource Control
        Handling ObjectDataSource Control Events
        Concurrency and the ObjectDataSource Control
        Extending the ObjectDataSource Control
        Summary
        Chapter 16. Building Data Access Components
        Connected Data Access
        Disconnected Data Access
        Executing Asynchronous Database Commands
        Building Database Objects with the .NET Framework
        Summary
      - Part V: Site Navigation
        Chapter 17. Using the Navigation Controls
        Understanding Site Maps
        Using the SiteMapPath Control
        Using the Menu Control
        Using the TreeView Control
        Building a SQL Hierarchical Data Source Control
        Summary
        Chapter 18. Using Site Maps
        Using the SiteMapDataSource Control
        Using the SiteMap Class
        Advanced Site Map Configuration
        Creating Custom Site Map Providers
        Generating a Google SiteMap File
        Summary
        Chapter 19. Advanced Navigation
        Remapping URLs
        Using the VirtualPathProvider Class
        Summary
      - Part VI: Security
        Chapter 20. Using the Login Controls
        Overview of the Login Controls
        Using the Login Control
        Using the CreateUserWizard Control
        Using the LoginStatus Control
        Using the LoginName Control
        Using the ChangePassword Control
        Using the PasswordRecovery Control
        Using the LoginView Control
        Summary
        Chapter 21. Using ASP.NET Membership
        Configuring Authentication
        Configuring Authorization
        Using ASP.NET Membership
        Using the Role Manager
        Summary
      - Part VII: Building ASP.NET Applications
        Chapter 22. Maintaining Application State
        Using Browser Cookies
        Using Session State
        Using Profiles
        Summary
        Chapter 23. Caching Application Pages and Data
        Overview of Caching
        Using Page Output Caching
        Using Partial Page Caching
        Using DataSource Caching
        Using Data Caching
        Using SQL Cache Dependencies
        Summary
        Chapter 24. Localizing Applications for Multiple Languages
        Setting the Current Culture
        Using the CultureInfo Class
        Creating Local Resources
        Creating Global Resources
        Using the Localize Control
        Summary
        Chapter 25. Working with the HTTP Runtime
        Creating a Custom BuildProvider
        Creating a Custom ExpressionBuilder
        Creating HTTP Handlers
        Working with HTTP Applications and HTTP Modules
        Summary
        Chapter 26. Configuring Applications
        Overview of Website Configuration
        Using the Configuration API
        Creating Custom Configuration Sections
        Creating Encrypted Configuration Sections
        Summary
      - Part VIII: Building Applications with Web Parts
        Chapter 27. Introduction to Web Parts
        Overview of the Web Part Framework
        Creating a Simple Web Part Application
        Using Catalog Zones
        Using Editor Zones
        Using Connections Zones
        Summary
        Chapter 28. Building Web Parts
        Creating Simple Web Parts
        Filtering Web Parts
        Creating Custom Web Part Verbs
        Displaying Web Part Help
        Managing Web Parts with the WebPartManager Control
        Summary
        Chapter 29. Personalizing Web Parts
        Overview of Personalization
        Configuring Personalization
        Creating Personalizable Web Parts
        Administrating Personalization
        Creating Custom Personalization Providers
        Summary
        Chapter 30. Extending the Web Part Framework
        Creating Custom Web Part Zones
        Creating Custom Catalog Zones
        Creating Custom Editor Zones
        Creating Custom Web Part Display Modes
        Summary
      - Part IX: Custom Control Building
        Chapter 31. Building Custom Controls
        Overview of Custom Control Building
        View State and Control State
        Processing Postback Data and Events
        Working with Control Property Collections
        Creating a Better Designer Experience
        Summary
        Chapter 32. Integrating JavaScript in Custom Controls
        Using the ClientScriptManager Class
        Building JavaScript Controls
        Building AJAX Controls
        Summary
        Chapter 33. Building Templated Databound Controls
        Creating Templated Controls
        Creating Templated Databound Controls
        Summary
      - Part X: Sample Application
        Chapter 34. Building an E-Commerce Application
        Overview of the E-Commerce Application
        Using Master Pages, Themes, and User Controls
        Building a Component Library
        Creating a Custom Site Map Provider
        Creating a Shopping Cart
        Protecting Credit Card Numbers
        Handling Images
        Retrieving Data with AJAX
        Improving Performance Through Caching
        Conforming to Standards
        Summary
    - Secure ASP.NET AJAX Development by Jason Schmitt Publisher: Addison Wesley Professional Pub Date: November 17, 2006 Print ISBN-10: 0-321-49810-0 Print ISBN-13: 978-0-321-49810-6 Pages: 93
      - Section 1. AJAX, ASP.NET, and Atlas
        AJAX Concepts
        AJAX Implementations and Frameworks
        Microsoft Atlas and AJAX
      - Section 2. AJAX Security Pitfalls
        Is AJAX Secure?
        AJAX Security Pitfalls
      - Section 3. Securing ASP.NET AJAX
        ASP.NET AJAX Security Principles
        Principle 1: Validate All Input on the Server
        Principle 2: Protect Client Resources
        Principle 3: Authenticate Requests
        Principle 4: Protect Web Services
        Principle 5: Secure Data Access
      - Section 4. ASP.NET AJAX Security Testing
        Security Assurance Across the Life Cycle
        Security Requirements
        Security Testing Tools
        ASP.NET AJAX Security Checklist
    - Essential ASP.NET 2.0 by Fritz Onion, Keith Brown Publisher: Addison Wesley Professional Pub Date: October 30, 2006 Print ISBN-10: 0-321-23770-6 Print ISBN-13: 978-0-321-23770-5 Pages: 384
      - Chapter 1. Architecture
        Fundamentals
        Codebehind
        Page Lifecycle
        Compilation
        Summary
      - Chapter 2. User Interface Elements
        Page Templates
        Themes and Skins
        Fundamentals of Navigation Controls
        Control Adapters
        Summary
      - Chapter 3. Data Binding
        Declarative Data Binding
        Summary
      - Chapter 4. State Management
        Cross-Page Posting
        Wizard and MultiView Controls
        Profile
        Summary
      - Chapter 5. Security
        How Much Security Do I Need?
        Getting Started with Membership
        Provider Architecture
        MembershipProvider
        Choosing a Password Format
        Password Questions and Answers
        Configuring a Membership Provider
        Custom Providers
        Using the Membership Class to Access Your Provider
        SQL Database Permissions
        The LoginView and Other Controls
        The Role Manager
        Configuring the Role Manager and Provider
        Other Role Providers
        A Word about Machine Keys
        Cookieless Forms Authentication
        SiteMapProvider Security Trimming
        Configuration File Encryption
        Summary
      - Chapter 6. Web Parts
        Web Part Fundamentals
        Summary
      - Chapter 7. Diagnostics
        Health Monitoring and Web Events
        Web Event Hierarchy
        Which Events Should I Monitor?
        Built-in Providers
        Buffering
        Registering for Events
        Throttling and Profiles
        Mapping the Health Monitoring Configuration Section
        Custom Web Events
        Custom Providers
        Tracing in ASP.NET 2.0
        Event Tracing for Windows: Debugging Without a Debugger
        Summary
      - Chapter 8. Performance
        Caching
        Client Callbacks
        Summary
      - Chapter 9. Asynchrony
        The Need for Asynchrony
        Techniques for Issuing Asynchronous Tasks
        Asynchronous Pages
        Summary
    - Programming Microsoft® ADO.NET 2.0 Core Reference by David Sceppa Publisher: Microsoft Press Pub Date: May 17, 2006 Print ISBN-10: 0-7356-2206-X Print ISBN-13: 978-0-7356-2206-7 Pages: 800
      - Part I: Getting Started with Microsoft ADO.NET 2.0
        Chapter 1. Overview of ADO.NET
        No New Object Model?!?
        The ADO.NET Object Model
        Questions That Should Be Asked More Frequently
        Chapter 2. Building Your First ADO.NET Application with Microsoft Visual Studio 2005
        Everyone Loves a Demo
        Creating Your Data Access Form Without Code
        Questions That Should Be Asked More Frequently
      - Part II: Getting Connected: Using a .NET Data Provider
        Chapter 3. Connecting to Your Database
        Creating SqlConnection Objects
        Opening SqlConnection Objects
        Closing SqlConnection Objects
        Cleaning Up After Yourself
        Connection Strings
        Connection Pooling
        Using the SqlConnection as a Starting Point
        Visual Studio Design-Time Features
        SqlConnection Object Reference
        Questions That Should Be Asked More Frequently
        Chapter 4. Querying Your Database
        Using SqlCommand Objects in Code
        Working with the SqlDataReader
        Working with Parameterized Queries
        Microsoft Visual Studio Design-Time Features
        Object Reference for SqlCommand, SqlDataReader, and SqlParameter
        Questions That Should Be Asked More Frequently
        Chapter 5. Retrieving Data Using SqlDataAdapter Objects
        What Is a SqlDataAdapter Object?
        Creating and Using SqlDataAdapter Objects
        Visual Studio 2005 Design-Time Features
        SqlDataAdapter Reference
        Questions That Should Be Asked More Frequently
      - Part III: Working with Data Offline—The ADO.NET DataSet
        Chapter 6. Working with DataSet Objects
        Features of the DataSet Class
        Using DataSet Objects
        Working with DataSet Objects in Visual Studio
        DataSet, DataTable, DataColumn, DataRow, UniqueConstraint, and ForeignKeyConstraint Class Reference
        Questions That Should Be Asked More Frequently
        Chapter 7. Working with Relational Data
        A Brief Overview of Relational Data Access
        Working with DataRelation Objects in Code
        Creating DataRelation Objects in Microsoft Visual Studio
        DataRelation Object Reference
        Questions That Should Be Asked More Frequently
        Chapter 8. Sorting, Searching, and Filtering
        Using the DataTable Class's Searching and Filtering Features
        What Is a DataView Object?
        Working with DataView Objects in Code
        Creating DataView Objects in Microsoft Visual Studio
        DataView Object Reference
        Questions That Should Be Asked More Frequently
        Chapter 9. Working with Strongly Typed DataSet Objects and TableAdapters
        Strongly Typed DataSets
        Creating Strongly Typed DataSet Objects
        Using Strongly Typed DataSet Objects
        When to Use Strongly Typed DataSet Objects
        Introducing TableAdapters
        Choosing Your Path
        Questions That Should Be Asked More Frequently
        Chapter 10. Submitting Updates to Your Database
        Submitting Updates Using Parameterized SqlCommands
        Submitting Updates Using a SqlDataAdapter
        Using SqlDataAdapter Objects to Submit Updates
        Manually Configuring Your SqlDataAdapter Objects
        Using a SqlCommandBuilder to Generate Updating Logic
        Using the Visual Studio TableAdapter Configuration Wizard to Generate Updating Logic
        Return of the DataAdapters!
        Submitting Updates in SqlTransactions
        SqlCommandBuilder Object Reference
        Questions That Should Be Asked More Frequently
        Chapter 11. Advanced Updating Scenarios
        Refreshing a Row After Submitting an Update
        Retrieving Newly Generated Auto-Increment Values
        Submitting Hierarchical Changes
        Isolating and Reintegrating Changes
        Handling Failed Update Attempts
        Working with Distributed Transactions
        Batch Queries
        SQL Bulk Copy
        DataSet Objects and Transactions
        When Handling Advanced Updating Scenarios, Use ADO.NET
        Questions That Should Be Asked More Frequently
        Chapter 12. Working with XML Data
        Bridging the Gap Between XML and Data Access
        Reading and Writing XML Data
        DataSet + XmlDocument = XmlDataDocument
        Using SQL Server 2005's XML Features
        Retrieving XML Data from SQL Server 2000 via SELECT...FOR XML
        The SQL XML .NET Data Provider
        A Simple ADO.NET and XML Sample
        Questions That Should Be Asked More Frequently
      - Part IV: Building Effective Applications with ADO.NET 2.0
        Chapter 13. Building Effective Microsoft Windows—Based Applications
        Building a User Interface Quickly by Using Data Binding
        Application Design Considerations
        Questions That Should Be Asked More Frequently
        Chapter 14. Building Effective Web Applications
        Brief Introduction to Web Applications
        Connecting to Your Database
        Challenges Interacting with Databases in ASP.NET 1.0
        Introducing Data Source Controls
        Caching Data Between Roundtrips
        Paging
        Questions That Should Be Asked More Frequently
        Chapter 15. SQL Server 2005 Common Language Runtime Integration
        Extending SQL Server the Old Way—Extended Stored Procedures
        Extending SQL Server the New Way—CLR Integration
        Using Microsoft Visual Studio 2005 to Simplify Building SQL CLR Code
        SQL CLR Scenarios
        Creating a SQL CLR User-Defined Type
        Summary
        Questions That Should Be Asked More Frequently
      - Part V: Appendixes
        Appendix A. Using Other .NET Data Providers
        The Provider Factory Model
        The ODBC .NET Data Provider
        The OLE DB .NET Data Provider
        The Oracle Client .NET Data Provider
        Appendix B. Samples and Tools
        Sample .NET Data Provider—DSP
        ADO.NET Data Explorer
        AdapterSet
        About the Author
    - Programming Microsoft® ASP.NET 2.0 Applications: Advanced Topics by Dino Esposito - Solid Quality Learning Publisher: Microsoft Press Pub Date: February 14, 2006 Print ISBN-10: 0-7356-2177-2 Print ISBN-13: 978-0-7356-2177-0 Pages: 688
      - Part I: Inside the ASP.NET Machinery
        Chapter 1. The ASP.NET Compilation Model
        The ASP.NET Runtime Environment
        Application Precompilation
        Building Blocks of ASP.NET Compilation
        Conclusion
        Chapter 2. HTTP Handlers and Modules
        Quick Overview of the IIS Extensibility API
        Writing HTTP Handlers
        Writing HTTP Modules
        Conclusion
        Chapter 3. ASP.NET Configuration
        The ASP.NET Configuration Hierarchy
        Managing Configuration Data
        Conclusion
        Chapter 4. Building Custom ASP.NET Providers
        The Pattern of Providers
        Built-In ASP.NET Providers
        Roll Your Own Provider
        Conclusion
        Chapter 5. Building Feature-Rich Pages
        Building Asynchronous Pages
        Building Custom Expressions
        Building Parser Filters for ASP.NET Pages
        Conclusion
      - Part II: Special Features
        Chapter 6. Working with Script Code
        Adding Client-Side Script to Pages
        Script Callbacks
        The Ajax.NET Library
        Conclusion
        Chapter 7. Composing Pages with Web Parts
        Web Parts at a Glance
        Building Web Parts
        Editing and Listing Web Parts
        Connecting Web Parts
        Conclusion
        Chapter 8. Programming for Mobility
        Overview of Mobile Controls
        Developing Mobile Applications
        Conclusion
        Chapter 9. Working with Images
        Accessing Images from Web Pages
        Accessing Database Images
        Generating Images Dynamically
        Conclusion
        Chapter 10. Site Navigation
        Defining Site Map Information
        Accessing Site Map Information
        Displaying Site Map Information
        Conclusion
      - Part III: ASP.NET Controls
        Chapter 11. ASP.NET Iterative Controls
        What Is an Iterative Control, Anyway?
        The Repeater Control
        The DataList Control
        Conclusion
        Chapter 12. ASP.NET Web User Controls
        What's a User Control, Anyway?
        Developing User Controls
        Getting Serious About User Controls
        Conclusion
        Chapter 13. Creating Custom ASP.NET Controls
        Extending Existing Controls
        Building Controls from Scratch
        Building Rich Controls
        Conclusion
        Chapter 14. Data-Bound and Templated Controls
        Designing a Data-Bound Control
        Building a Simple Data-Bound Control
        Building a List Data-Bound Control
        Building a Composite Templated Control
        Conclusion
        Chapter 15. Design-Time Support for Custom Controls
        The Design-Time Architecture in .NET
        Design-Time Attributes
        Rendering Types
        Custom Designers
        Conclusion
    - Microsoft E-Learning
      - Mircosoft E-Learning Course 2914: Writing Master Pages and Content Pages in Microsoft® ASP.NET 2.0
      - Mircosoft E-Learning Course 2915: Working with ADO.NET 2.0 Within Microsoft® ASP.NET 2.0
      - Mircosoft E-Learning Course 2913: Creating Your First Microsoft® ASP.NET 2.0 Web Application
  - SQL
    - Microsoft® SQL Server 2005: Changing the Paradigm (SQL Server 2005 Public Beta Edition) by Scalability Experts, Inc. Publisher: Sams Pub Date: August 30, 2005 Print ISBN-10: 0-672-32778-3 Print ISBN-13: 978-0-672-32778-0 Pages: 504
      - Chapter 1. Changes in the Database Paradigm: How SQL Server 2005 Redefines the Role of a DBA
        SQL Server Philosophy
        History
        SQL Server 2005 and Database Administrators
        Summary
      - Chapter 2. SQL Server 2005 Database Engine Architectural Changes
        The SQL Server Operating System (SQLOS)
        Non-Uniform Memory Access (NUMA) Architecture Support
        Query Optimization and Execution
        Row Versioning
        System Metadata Access and the Security Architecture
        Storage Engine and I/O Changes
        Summary
      - Chapter 3. SQL Server 2005 Setup and Deployment
        SQL Server 2005 Editions
        Hardware and Software Requirements for Installing SQL Server 2005
        SQL Server 2005 Setup Enhancements
        Upgrading to SQL Server 2005
        Summary
      - Chapter 4. A Tour of New Features in SQL Server 2005
        Setup Enhancements
        Database Administration and Management
        Database Engine Enhancements
        T-SQL Enhancements
        SQL Server 2005 Security
        Performance Monitoring and Tuning Enhancements
        High-Availability Features
        Business Intelligence Redefined
        Notification Services
        Full-Text Search Enhancements
        Documentation Improvements
        Summary
      - Chapter 5. SQL Server 2005 Tools and Utilities
        Tools and Utilities Overview
        Management and Authoring
        Performance Monitoring, Tuning, and Optimization Tools
        Operations and Configuration
        Management APIs
        Summary
      - Chapter 6. Transact-SQL Enhancements
        T-SQL Versus SQLCLR
        The TOP Operator
        The TABLESAMPLE Clause
        Common Table Expressions (CTEs)
        Large Object Data Type Enhancements
        T-SQL Error Handling
        DDL Triggers
        Event Notifications
        Snapshot Isolation
        Ranking Functions
        New Relational Operators: PIVOT, UNPIVOT, and APPLY
        The OUTPUT Clause
        The BULK Rowset Provider
        New Declarative Referential Integrity Actions
        Metadata Views and Dynamic Management Views
        Miscellaneous T-SQL Enhancements
        Summary
      - Chapter 7. SQL Server 2005 Security
        An Introduction to Security in SQL Server 2005
        Authentication
        Authorization
        Auditing Enhancements
        Cryptography Support
        Surface Area Configuration (SAC)
        SQL Server Agent Security Overview
        SQLCLR Security Overview
        Service Broker Security Overview
        Summary
      - Chapter 8. Reliability and High Availability in the Database Engine
        Reliability Enhancements
        Availability Enhancements
        Summary
      - Chapter 9. Performance Analysis and Tuning
        Physical Database Design, Analysis, and Tuning
        Troubleshooting Locking and Blocking
        Query Performance Tuning
        Designing Applications for Performance
        Performance Monitoring and Tuning Tools
        Summary
      - Chapter 10. XML and Web Services Support in SQL Server 2005
        XML Primer
        The xml Data Type
        FOR XML Enhancements
        Native XML Web Services Support
        Summary
      - Chapter 11. SQL Server 2005 and .NET Integration
        What Is the .NET Framework?
        .NET Framework Integration
        SQLCLR Integration Examples
        Summary
      - Chapter 12. SQL Server Integration Services Overview
        New SSIS Features
        The SSIS Architecture
        The SSIS Toolkit
        Designing SSIS Packages
        The World of Wizards
        SSIS and Data Warehousing
        Summary
      - Chapter 13. What's New in SQL Server Analysis Services 2005
        OLAP, Data Warehousing, Business Intelligence, and Data Mining
        Analysis Services Fundamentals
        Analysis Services 2005 Enhancements
        Performance Tuning for Analysis Services
        Administering Analysis Services
        Analysis Services Security Overview
        Migrating from SQL Server 2000 Analysis Services to SQL Server 2005 Analysis Services
        SQL Server 2005 Reporting Services (SSRS) Overview
        Summary
      - Chapter 14. SQL Server Service Broker
        An Introduction to Asynchronous Messaging
        Understanding Service Broker
        Service Broker Operations and Troubleshooting
        Service Broker Security Overview
        Summary
      - Chapter 15. SQL Sever 2005 Support for 64-Bit Processors
        64-Bit Processor Usage Scenarios
        SQL Server 2005 (64-Bit) in Detail
        Summary
    - SQL Cookbook by Anthony Molinaro Publisher: O'Reilly Pub Date: December 2005 Print ISBN-10: 0-596-00976-3 Print ISBN-13: 978-0-59-600976-2 Pages: 628
      - Chapter 1. Retrieving Records
        Recipe 1.1. Retrieving All Rows and Columns from a Table
        Recipe 1.2. Retrieving a Subset of Rows from a Table
        Recipe 1.3. Finding Rows That Satisfy Multiple Conditions
        Recipe 1.4. Retrieving a Subset of Columns from a Table
        Recipe 1.5. Providing Meaningful Names for Columns
        Recipe 1.6. Referencing an Aliased Column in the WHERE Clause
        Recipe 1.7. Concatenating Column Values
        Recipe 1.8. Using Conditional Logic in a SELECT Statement
        Recipe 1.9. Limiting the Number of Rows Returned
        Recipe 1.10. Returning n Random Records from a Table
        Recipe 1.11. Finding Null Values
        Recipe 1.12. Transforming Nulls into Real Values
        Recipe 1.13. Searching for Patterns
      - Chapter 2. Sorting Query Results
        Recipe 2.1. Returning Query Results in a Specified Order
        Recipe 2.2. Sorting by Multiple Fields
        Recipe 2.3. Sorting by Substrings
        Recipe 2.4. Sorting Mixed Alphanumeric Data
        Recipe 2.5. Dealing with Nulls when Sorting
        Recipe 2.6. Sorting on a Data Dependent Key
      - Chapter 3. Working with Multiple Tables
        Recipe 3.1. Stacking One Rowset atop Another
        Recipe 3.2. Combining Related Rows
        Recipe 3.3. Finding Rows in Common Between Two Tables
        Recipe 3.4. Retrieving Values from One Table That Do Not Exist in Another
        Recipe 3.5. Retrieving Rows from One Table That Do Not Correspond to Rows in Another
        Recipe 3.6. Adding Joins to a Query Without Interfering with Other Joins
        Recipe 3.7. Determining Whether Two Tables Have the Same Data
        Recipe 3.8. Identifying and Avoiding Cartesian Products
        Recipe 3.9. Performing Joins when Using Aggregates
        Recipe 3.10. Performing Outer Joins when Using Aggregates
        Recipe 3.11. Returning Missing Data from Multiple Tables
        Recipe 3.12. Using NULLs in Operations and Comparisons
      - Chapter 4. Inserting, Updating, Deleting
        Recipe 4.1. Inserting a New Record
        Recipe 4.2. Inserting Default Values
        Recipe 4.3. Overriding a Default Value with NULL
        Recipe 4.4. Copying Rows from One Table into Another
        Recipe 4.5. Copying a Table Definition
        Recipe 4.6. Inserting into Multiple Tables at Once
        Recipe 4.7. Blocking Inserts to Certain Columns
        Recipe 4.8. Modifying Records in a Table
        Recipe 4.9. Updating when Corresponding Rows Exist
        Recipe 4.10. Updating with Values from Another Table
        Recipe 4.11. Merging Records
        Recipe 4.12. Deleting All Records from a Table
        Recipe 4.13. Deleting Specific Records
        Recipe 4.14. Deleting a Single Record
        Recipe 4.15. Deleting Referential Integrity Violations
        Recipe 4.16. Deleting Duplicate Records
        Recipe 4.17. Deleting Records Referenced from Another Table
      - Chapter 5. Metadata Queries
        Recipe 5.1. Listing Tables in a Schema
        Recipe 5.2. Listing a Table's Columns
        Recipe 5.3. Listing Indexed Columns for a Table
        Recipe 5.4. Listing Constraints on a Table
        Recipe 5.5. Listing Foreign Keys Without Corresponding Indexes
        Recipe 5.6. Using SQL to Generate SQL
        Recipe 5.7. Describing the Data Dictionary Views in an Oracle Database
      - Chapter 6. Working with Strings
        Recipe 6.1. Walking a String
        Recipe 6.2. Embedding Quotes Within String Literals
        Recipe 6.3. Counting the Occurrences of a Character in a String
        Recipe 6.4. Removing Unwanted Characters from a String
        Recipe 6.5. Separating Numeric and Character Data
        Recipe 6.6. Determining Whether a String Is Alphanumeric
        Recipe 6.7. Extracting Initials from a Name
        Recipe 6.8. Ordering by Parts of a String
        Recipe 6.9. Ordering by a Number in a String
        Recipe 6.10. Creating a Delimited List from Table Rows
        Recipe 6.11. Converting Delimited Data into a Multi-Valued IN-List
        Recipe 6.12. Alphabetizing a String
        Recipe 6.13. Identifying Strings That Can Be Treated as Numbers
        Recipe 6.14. Extracting the nth Delimited Substring
        Recipe 6.15. Parsing an IP Address
      - Chapter 7. Working with Numbers
        Recipe 7.1. Computing an Average
        Recipe 7.2. Finding the Min/Max Value in a Column
        Recipe 7.3. Summing the Values in a Column
        Recipe 7.4. Counting Rows in a Table
        Recipe 7.5. Counting Values in a Column
        Recipe 7.6. Generating a Running Total
        Recipe 7.7. Generating a Running Product
        Recipe 7.8. Calculating a Running Difference
        Recipe 7.9. Calculating a Mode
        Recipe 7.10. Calculating a Median
        Recipe 7.11. Determining the Percentage of a Total
        Recipe 7.12. Aggregating Nullable Columns
        Recipe 7.13. Computing Averages Without High and Low Values
        Recipe 7.14. Converting Alphanumeric Strings into Numbers
        Recipe 7.15. Changing Values in a Running Total
      - Chapter 8. Date Arithmetic
        Recipe 8.1. Adding and Subtracting Days, Months, and Years
        Recipe 8.2. Determining the Number of Days Between Two Dates
        Recipe 8.3. Determining the Number of Business Days Between Two Dates
        Recipe 8.4. Determining the Number of Months or Years Between Two Dates
        Recipe 8.5. Determining the Number of Seconds, Minutes, or Hours Between Two Dates
        Recipe 8.6. Counting the Occurrences of Weekdays in a Year
        Recipe 8.7. Determining the Date Difference Between the Current Record and the Next Record
      - Chapter 9. Date Manipulation
        Recipe 9.1. Determining if a Year Is a Leap Year
        Recipe 9.2. Determining the Number of Days in a Year
        Recipe 9.3. Extracting Units of Time from a Date
        Recipe 9.4. Determining the First and Last Day of a Month
        Recipe 9.5. Determining All Dates for a Particular Weekday Throughout a Year
        Recipe 9.6. Determining the Date of the First and Last Occurrence of a Specific Weekday in a Month
        Recipe 9.7. Creating a Calendar
        Recipe 9.8. Listing Quarter Start and End Dates for the Year
        Recipe 9.9. Determining Quarter Start and End Dates for a Given Quarter
        Recipe 9.10. Filling in Missing Dates
        Recipe 9.11. Searching on Specific Units of Time
        Recipe 9.12. Comparing Records Using Specific Parts of a Date
        Recipe 9.13. Identifying Overlapping Date Ranges
      - Chapter 10. Working with Ranges
        Recipe 10.1. Locating a Range of Consecutive Values
        Recipe 10.2. Finding Differences Between Rows in the Same Group or Partition
        Recipe 10.3. Locating the Beginning and End of a Range of Consecutive Values
        Recipe 10.4. Filling in Missing Values in a Range of Values
        Recipe 10.5. Generating Consecutive Numeric Values
      - Chapter 11. Advanced Searching
        Recipe 11.1. Paginating Through a Result Set
        Recipe 11.2. Skipping n Rows from a Table
        Recipe 11.3. Incorporating OR Logic when Using Outer Joins
        Recipe 11.4. Determining Which Rows Are Reciprocals
        Recipe 11.5. Selecting the Top n Records
        Recipe 11.6. Finding Records with the Highest and Lowest Values
        Recipe 11.7. Investigating Future Rows
        Recipe 11.8. Shifting Row Values
        Recipe 11.9. Ranking Results
        Recipe 11.10. Suppressing Duplicates
        Recipe 11.11. Finding Knight Values
        Recipe 11.12. Generating Simple Forecasts
      - Chapter 12. Reporting and Warehousing
        Recipe 12.1. Pivoting a Result Set into One Row
        Recipe 12.2. Pivoting a Result Set into Multiple Rows
        Recipe 12.3. Reverse Pivoting a Result Set
        Recipe 12.4. Reverse Pivoting a Result Set into One Column
        Recipe 12.5. Suppressing Repeating Values from a Result Set
        Recipe 12.6. Pivoting a Result Set to Facilitate Inter-Row Calculations
        Recipe 12.7. Creating Buckets of Data, of a Fixed Size
        Recipe 12.8. Creating a Predefined Number of Buckets
        Recipe 12.9. Creating Horizontal Histograms
        Recipe 12.10. Creating Vertical Histograms
        Recipe 12.11. Returning Non-GROUP BY Columns
        Recipe 12.12. Calculating Simple Subtotals
        Recipe 12.13. Calculating Subtotals for All Possible Expression Combinations
        Recipe 12.14. Identifying Rows That Are Not Subtotals
        Recipe 12.15. Using Case Expressions to Flag Rows
        Recipe 12.16. Creating a Sparse Matrix
        Recipe 12.17. Grouping Rows by Units of Time
        Recipe 12.18. Performing Aggregations over Different Groups/Partitions Simultaneously
        Recipe 12.19. Performing Aggregations over a Moving Range of Values
        Recipe 12.20. Pivoting a Result Set with Subtotals
      - Chapter 13. Hierarchical Queries
        Recipe 13.1. Expressing a Parent-Child Relationship
        Recipe 13.2. Expressing a Child-Parent-Grandparent Relationship
        Recipe 13.3. Creating a Hierarchical View of a Table
        Recipe 13.4. Finding All Child Rows for a Given Parent Row
        Recipe 13.5. Determining Which Rows Are Leaf, Branch, or Root Nodes
      - Chapter 14. Odds 'n' Ends
        Recipe 14.1. Creating Cross-Tab Reports Using SQL Server's PIVOT Operator
        Recipe 14.2. Unpivoting a Cross-Tab Report Using SQL Server's UNPIVOT Operator
        Recipe 14.3. Transposing a Result Set Using Oracle's MODEL Clause
        Recipe 14.4. Extracting Elements of a String from Unfixed Locations
        Recipe 14.5. Finding the Number of Days in a Year (an Alternate Solution for Oracle)
        Recipe 14.6. Searching for Mixed Alphanumeric Strings
        Recipe 14.7. Converting Whole Numbers to Binary Using Oracle
        Recipe 14.8. Pivoting a Ranked Result Set
        Recipe 14.9. Adding a Column Header into a Double Pivoted Result Set
        Recipe 14.10. Converting a Scalar Subquery to a Composite Subquery in Oracle
        Recipe 14.11. Parsing Serialized Data into Rows
        Recipe 14.12. Calculating Percent Relative to Total
        Recipe 14.13. Creating CSV Output from Oracle
        Recipe 14.14. Finding Text Not Matching a Pattern (Oracle)
        Recipe 14.15. Transforming Data with an Inline View
        Recipe 14.16. Testing for Existence of a Value Within a Group
      - Appendix A. Window Function Refresher
        Recipe A.1. Grouping
        Recipe A.2. Windowing
      - Appendix B. Rozenshtein Revisited
        Recipe B.1. Rozenshtein's Example Tables
        Recipe B.2. Answering Questions Involving Negation
        Recipe B.3. Answering Questions Involving "at Most"
        Recipe B.4. Answering Questions Involving "at Least"
        Recipe B.5. Answering Questions Involving "Exactly"
        Recipe B.6. Answering Questions Involving "Any" or "All"
    - SQL Server 2005 Reporting Essentials by Bill Hamilton Publisher: O'Reilly Pub Date: November 01, 2006 Print ISBN-10: 0-596-52941-4 Print ISBN-13: 978-0-59-652941-3 Pages: 80
      - Chapter 1. Getting Started
      - Chapter 2. Set Up and Configuration
      - Chapter 3. Key Concepts
      - Chapter 4. Report Manager
      - Chapter 5. Report Designer
        Section 5.1. Create a Report Server Project
        Section 5.2. Create a Report
        Section 5.3. Publish a Report
      - Chapter 6. Report Model Designer
        Section 6.1. Create a Data Source
        Section 6.2. Create a Data Source View
        Section 6.3. Create a Report Model
        Section 6.4. Publish a Report Model
      - Chapter 7. Report Builder
        Section 7.1. Create a Data Source
        Section 7.2. Create a Report Model
        Section 7.3. Create a Report Layout
        Section 7.4. Publish (Save) a Report
        Section 7.5. Run a Report
        Section 7.6. Open a Saved Report
        Section 7.7. Report Snapshots and History
        Section 7.8. Subscriptions
      - Chapter 8. Integrating Reports into Applications
        Section 8.1. URL-based
        Section 8.2. Report Viewer Control
        Section 8.3. Web Services
    - SQL Server 2005 Practical Troubleshooting: The Database Engine by Ken Henderson Publisher: Addison Wesley Professional Pub Date: December 11, 2006 Print ISBN-10: 0-321-44774-3 Print ISBN-13: 978-0-321-44774-6 Pages: 480
      - Chapter 1. Waiting and Blocking Issues
        Wait Types
        Troubleshooting Blocking
        Identifying Blocking
        Identifying the Cause of Blocking
        Resource Type Specifics
        Deadlocks
        Monitoring Blocking
        Conclusion
        Other Resources
      - Chapter 2. Data Corruption and Recovery Issues
        Fundamentals
        SQL Server 2005 Storage Internals
        SQL Server 2005 Enhancements
        Data Recovery Best Practices
        Data Recovery Troubleshooting Scenarios
        User Database Inaccessible
        BACKUP/RESTORE Failures
        Database Consistency Errors
      - Chapter 3. Memory Issues
        Introduction to Windows Memory Management
        SQLOS and SQL Server Memory Management
      - Chapter 4. Procedure Cache Issues
        Procedure Cache Architecture
        Common Cache-Related Problems and Solutions
        Conclusion
      - Chapter 5. Query Processor Issues
        Query Processor Basics
        Common Issues
        Troubleshooting
        Best Practices
        Further Reading
      - Chapter 6. Server Crashes and Other Critical Failures
        Fundamentals
        Critical Errors and Server Recovery Troubleshooting
      - Chapter 7. Service Broker Issues
        Broker Overview
        Primary Diagnostic Tools and Methods
        Broker Troubleshooting Walkthrough
        Other Service Broker Diagnostic Tools
        Further Reading
      - Chapter 8. SQLOS and Scheduling Issues
        SQLOS Architecture
        Configuration and Troubleshooting
        Further Reading
      - Chapter 9. Tempdb Issues
        What Has Improved in SQL Server 2005?
        How Is Tempdb Space Consumed?
        Practical Troubleshooting
        Conclusion
      - Chapter 10. Clustering Issues
        Example
        Tools
        Get Performance to an Acceptable Level
        Conclusion
      - The Aging Champion
    - Programming Microsoft® SQL Server™ 2005 by Andrew J. Brust, Stephen Forte Publisher: Microsoft Press Pub Date: May 16, 2006 Print ISBN-10: 0-7356-1923-9 Print ISBN-13: 978-0-7356-1923-4 Pages: 600
      - Part I: Design Fundamentals and Core Technologies
        Chapter 1. Overview
        A Tough Act to Follow
        Industry Trends, SQL Server Features, and a Book to Show You the Way
        A Collaborative Effort for, and by, Developers
        Chapter 2. Exploring the T-SQL Enhancements in SQL Server 2005
        Introducing SQL Server Management Studio
        Common Table Expressions
        The PIVOT and UNPIVOT Operators
        TOP Enhancements
        Ranking Functions
        Exception Handling in Transactions
        New Data Types
        The WAITFOR Command
        DDL Triggers and Notifications
        SNAPSHOT Isolation
        Statement-Level Recompile
        Summary
        Chapter 3. An Overview of SQL CLR
        Getting Started: Enabling CLR Integration
        Visual Studio/SQL Server Integration
        Your First SQL CLR Stored Procedure
        CLR Stored Procedures and Server-Side Data Access
        Deployment
        CLR Functions
        CLR Triggers
        CLR Aggregates
        CLR Types
        Security
        Examining and Managing CLR Types in a Database
        Best Practices for SQL CLR Usage
        Summary
        Chapter 4. XML and the Relational Database
        XML in SQL Server 2000
        The XML Data Type
        FOR XML Commands
        Querying XML Data Using XQuery
        Summary
        Chapter 5. Introducing SQL Server Management Studio
        The New Management Studio Interface
        Using Object Explorer
        Management Studio Solutions, Projects, and Files
        Creating Objects
        Creating Queries
        Using Templates
        Maintenance Features
        Performance Tools
        Summary
        Chapter 6. Using SQL Server Management Objects (SMO)
        What Is SMO?
        Working with SMO in Visual Studio
        Summary
        Chapter 7. SQL Server 2005 Security
        Four Themes of the Security Framework
        SQL Server 2005 Security Overview
        Authentication and Authorization
        Encryption Support in SQL Server 2005
        Protecting SQL Server 2005
        How Hackers Attack SQL Server
        Summary
      - Part II: Application Development and Reach Technologies
        Chapter 8. ADO.NET 2.0, Typed DataSet Objects, and .NET Data Binding
        A Brief History of Data Access Object Models
        What's New in ADO.NET 2.0?
        Typed DataSet Enhancements
        "Pure" ADO.NET: Working in Code
        It's Not Just Text: Processing XML Columns with ADO.NET and the System.Xml Namespace
        Embedding SQL CLR Objects in Typed DataSet Objects
        Windows Forms Data Binding
        Data Binding on the Web
        Summary
        Chapter 9. Debugging
        About the Sample Code
        Ad Hoc Debugging
        Application Debugging
        Mixing SQL CLR and T-SQL Code
        Test Script Debugging
        Debugging Queries External to Visual Studio
        Remote Debugging
        Summary
        Chapter 10. SQL Server 2005 Native XML Web Services
        Understanding Native XML Web Services
        Exposing SQL Programmability as Web Services
        Example Native XML Web Services Project
        Best Practices for Using Native XML Web Services
        Summary
        Chapter 11. Transactions
        What Is a Transaction?
        Local Transactions Support in SQL Server 2005
        Transaction Terminology
        Isolation Levels
        Distributed Transactions
        Transactions in SQL CLR (CLR Integration)
        Putting It All Together
        Summary
        Chapter 12. SQL Server Service Broker: The New Middleware
        What Is Middleware?
        What Is SQL Server Service Broker?
        What Is a SQL Server Service Broker Application?
        Service Broker Architecture
        Integrated Management and Operation
        Routing and Load Balancing
        Service Broker Programming in T-SQL
        Defining Service Broker Objects
        Service Broker and Query Notification
        Service Broker's Place in the Middleware World
        Summary
        Chapter 13. Using SQL Server 2005 Notification Services
        What Is a Notification Application?
        Working with Notification Services
        A Sample Notification Application
        Summary
        Chapter 14. Developing Desktop Applications with SQL Server Express Edition
        What Is SQL Server Express Edition?
        Configuration
        Working with SQL Server Express Edition
        Installing SQL Server Express Edition
        Summary
        Chapter 15. Developing Applications with SQL Server 2005 Everywhere Edition and SQL Server Merge Replication
        SQL Everywhere Integration with SQL Server 2005
        Creating a SQL Everywhere Application with SQL Server Replication and Visual Studio 2005
        Summary
      - Part III: Reporting and Business Intelligence
        Chapter 16. Using SQL Server 2005 Integration Services
        History of Data Transfer in SQL Server
        Working with Integration Services Packages
        Using Integration Services Packages
        Security
        Programming Integration Services
        Extensibility
        Summary
        Chapter 17. Basic OLAP
        Wherefore BI?
        OLAP 101
        Building Your First Cube
        Running Queries
        Summary
        Chapter 18. Advanced OLAP
        What We'll Cover in This Chapter
        Advanced Dimensions and Measures
        Calculations
        Key Performance Indicators
        Actions
        Partitions, Aggregation Design, Storage Settings, and Proactive Caching
        Perspectives
        Translations
        Roles
        Summary
        Chapter 19. OLAP Application Development
        Using Excel
        Beyond OWC: Full-On OLAP Development
        Summary
        Chapter 20. Extending Your Database System with Data Mining
        Why Mine Your Data?
        Getting Started
        Using the Data Mining Wizard and Data Mining Designer
        Using Data Mining Extensions
        Data Mining Applied
        Summary
        Chapter 21. Reporting Services
        Report Definition and Design
        Report Management
        Report Access and Delivery
        Report Server Architecture
        Summary
    - Hitchhiker's Guide to Visual Studio and SQL Server: Best Practice Architectures and Examples (7th Edition) by William R. Vaughn, Peter Blackburn Publisher: Addison-Wesley Professional; 7 edition (November 2, 2006) ISBN-10: 0321243625 ISBN-13: 978-0321243621 Pages: 1128
    - Microsoft® SQL Server 2005 Reporting Services by Michael Lisin, Jim Joseph Publisher: Sams Pub Date: March 22, 2006 Print ISBN-10: 0-672-32799-6 Print ISBN-13: 978-0-672-32799-5 Pages: 480
      - Part I: Introduction to Reporting Services
        Chapter 1. Introduction to SQL Server Reporting Services (SSRS)
        What Is SSRS?
        SSRS for End Users
        Overview of Features
        Enterprise Report Examples
        SSRS in the Report Development Life Cycle
        Editions of Reporting Services
        How Is SSRS Licensed?
        Summary
        Chapter 2. Reporting Services Capabilities: Presentation, Navigation, and Programmability
        Report Layouts
        Report Presentation (Rendering) Formats
        Report Items, Visual Effects, and Charting
        Report Navigation
        Ad Hoc Reports NEW in 2005
        Reporting Services Data Access Features
        Programmability
        Summary
        Chapter 3. Reporting Services Architecture
        Report Server Web and Windows Service
        Programmatic Interfaces
        Report Processor
        Command-Line Utilities
        Reporting Services Extensions
        Report Server Databases
        Scheduling and Delivery Processor
        Report Builder NEW in 2005
        Report Model Designer NEW in 2005
        Report Designer
        Report Manager
        SQL Server Management Studio NEW in 2005
        Reporting Services Configuration Tool NEW in 2005
        RSPrintClient Control NEW in 2005
        WMI Provider
        Performance Monitoring Objects
        Summary
        Chapter 4. Reporting Services Deployment Scenarios
        High-Availability Deployment Considerations
        Internet Deployment Considerations
        Minimum Hardware Requirements
        Software Requirements
        Key Features of SSRS by SQL Server 2005 Editions
        Licensing
        Summary
        Chapter 5. Installing Reporting Services
        Summary
      - Part II: Report Authoring from Basic to Advanced
        Chapter 6. Report Designer
        Two Main Report Designers from Microsoft
        Visual Studio Haves Versus Have Nots
        Solution, Project, File Hierarchy
        Generating Reports with Visual Studio
        Summary
        Chapter 7. Report Definition Language
        Language: A Way to Communicate
        Use of XML
        Declarative Programming
        Report Elements
        Summary
        Chapter 8. Expressions
        What Is an Expression?
        Expression Syntax
        Adding Expressions
        Collections
        Using Functions
        Other Functions
        Using Expressions to Change Report Item Properties and Behavior
        Example: Placing Emphasis on Certain Values
        Summary
        Chapter 9. Accessing Data
        Data-Processing Extensions
        Types of Data Sources
        Connection Strings
        Querying Data
        Adding a Data Source
        Summary
        Chapter 10. Report Parameters
        Setting Up Parameters
        Parameter Properties
        Data-Driven Parameters
        Parameters and Data Sources
        Expressions with Parameters
        Dynamic SQL with Parameters
        Parameter Dependencies
        Example Using MultiValueNEW in 2005
        Summary
        Chapter 11. Working with Report Items
        Data Regions, Containers, and Independent Report Items
        Report Designer's Toolbox
        Line Report Item
        Rectangle Report Item
        Image Report Item
        Textbox Report Item
        Table Report Item
        List Report Item
        Practical Application of Report Items
        Matrix Report Item
        Chart Report Item
        Chart Data (Value)
        Chart Series Groups
        Chart Category Groups
        Chart's RDL
        Practical Application of Chart and Matrix
        Report Body Versus Page Header/Footer
        Summary
        Chapter 12. Grouping, Sorting, and Aggregating Data, Working with Scope
        Grouping Data on a Report
        Sorting, Including Interactive User Sorting
        Interactive SortingNEW in 2005
        Data Source Sorting
        Data Region and Group Sorting
        Scope of an Aggregate Function
        Level and InScope Functions
        Summary
        Chapter 13. Advanced Report Formatting
        Formatting-Related Report Item Properties
        Formatting Numeric and Date/Time Values
        Standard Date/Time Format Strings
        Custom Date/Time Formatting
        Creating Alternating Colors for the Lines on a Report
        Paging Report
        Summary
        Chapter 14. Report Navigation
        Hyperlink (Jump to URL) Navigation
        BookmarkLink (Jump to Bookmark) Navigation
        Document Map
        Drillthrough (Jump to Report) Navigation
        Hiding Items and Toggle Items
        Practical Application of Action Items
        Summary
        Chapter 15. Working with Multidimensional Data Sources
        Analysis Services Concepts
        Data-Mining Concepts
        Summary
        Chapter 16. Ad Hoc Reporting New in 2005
        Issues Facing Ad Hoc Reporting
        Client-side Reporting with SSRS
        Report Models and the Model Designer
        Report Model Projects
        Model File Content
        Features of Report Builder
        Building Reports with Report Builder
        Summary
      - Part III: Reporting Services Administration and Operations
        Chapter 17. Managing Reports, Data Sources, and Models
        Deployment Options in Visual Studio
        Deployment Through Report Manager
        Deploying Reports Through SQL Server Management Studio
        Changing Report Properties
        Setting Report History and Snapshots
        My Reports
        Summary
        Chapter 18. Securing Report Server Items
        Reporting Services Security Model
        What Can Be Secured?
        How Role Assignments Work
        Relationships Between Roles, Tasks, and Users
        Overview of Built-In Roles
        Assigning Built-In Roles
        Defining Custom Roles
        Summary
        Chapter 19. Subscribing to Reports
        Overview of Subscriptions
        Overview of Delivery Extensions
        Creating a Simple Subscription
        Creating a Data-Driven Subscription
        Managing Subscriptions
        Summary
        Chapter 20. Report Execution and Processing
        Managing Schedules
        Report Execution and Processing
        Report Execution History
        Summary
        Chapter 21. Deploying and Configuring SSRS
        Overview of Deployment Scenarios
        Requirements for a Standard Deployment
        Requirements for a Scale-Out Deployment
        Configuring SSRS
        Key Management
        Summary
      - Part IV: Developing for Reporting Services
        Chapter 22. Implementing Custom Embedded Functions
        Adding Embedded Code
        Debugging Embedded Code
        Summary
        Chapter 23. How to Create and Call a Custom Assembly from a Report
        Strong-Named Custom Assemblies
        NET Security Primer for a SSRS Administrator
        Assemblies That Require Other Than Execute Permissions
        Debugging Custom Assemblies
        Summary
        Chapter 24. How to Integrate URL Access
        How to Integrate URL Access in an Application
        Summary
        Chapter 25. How to Use Reporting Services Web Services
        Report Management Web Service New in 2005 (ReportService2005.asmx)
        How to Script Reporting Services (Using the RS Utility)
        Working with Report Parameters
        Security When Calling a Web Service
        Some of the Commonly Used Methods with Short Code Snippets
        Summary
        Chapter 26. Writing Custom Reporting Services Extensions
        Common Considerations for Custom Reporting Services Extensions: Implementation, Deployment, and Security
        Delivery Extension
        Interactions Between User, SSRS, and a Delivery Extension
        Summary
        Chapter 27. Report Rendering Controls and SharePoint Services Web Parts
        Microsoft Visual Studio 2005 ReportViewer Web and Windows Controls New in 2005
        Microsoft SharePoint Web Parts
        Summary
        Chapter 28. Custom Report Definition Language (RDL) Generators and Customizing Report Definition
        Summary
      - Part V: Appendices
        Appendix A. References and Additional Reading
        Appendix B. Glossary
        Appendix C. FAQ
    - Microsoft E-Learning
      - Mircosoft E-Learning Course 2936: Installing and Securing Microsoft® SQL Server™ 2005
      - Mircosoft E-Learning Course 2937: Administering and Monitoring Microsoft® SQL Server™ 2005
      - Mircosoft E-Learning Course 2938: Data Availability Features in Microsoft® SQL Server™ 2005
      - Mircosoft E-Learning Course 2939: Programming Microsoft® SQL Server™ 2005
      - Mircosoft E-Learning Course 2940: Building Service and Notifications Using Microsoft® SQL Server™ 2005
      - Microsoft E-Learning Course 2941: Creating the Data Access Tier Using Microsoft® SQL Server™ 2005
      - Mircosoft E-Learning Course 2942: New Features of Microsoft® SQL Server™ 2005 Analysis Services
      - Microsoft E-Learning Course 2944: Updating Your Reporting Skills to Microsoft® SQL Server™ 2005 Reporting Services
  - Java
    - Java 1.5 Tiger: A Developer's Notebook
      - Chapter 1. What's New?
        Section 1.1. Working with Arrays
        Section 1.2. Using Queues
        Section 1.3. Ordering Queues Using Comparators
        Section 1.4. Overriding Return Types
        Section 1.5. Taking Advantage of Better Unicode
        Section 1.6. Adding StringBuilder to the Mix
      - Chapter 2. Generics
        Section 2.1. Using Type-Safe Lists
        Section 2.2. Using Type-Safe Maps
        Section 2.3. Iterating Over Parameterized Types
        Section 2.4. Accepting Parameterized Types as Arguments
        Section 2.5. Returning Parameterized Types
        Section 2.6. Using Parameterized Types as Type Parameters
        Section 2.7. Checking for Lint
        Section 2.8. Generics and Type Conversions
        Section 2.9. Using Type Wildcards
        Section 2.10. Writing Generic Types
        Section 2.11. Restricting Type Parameters
      - Chapter 3. Enumerated Types
        Section 3.1. Creating an Enum
        Section 3.2. Declaring Enums Inline
        Section 3.3. Iterating Over Enums
        Section 3.4. Switching on Enums
        Section 3.5. Maps of Enums
        Section 3.6. Sets of Enums
        Section 3.7. Adding Methods to an Enum
        Section 3.8. Implementing Interfaces with Enums
        Section 3.9. Value-Specific Class Bodies
        Section 3.10. Manually Defining an Enum
        Section 3.11. Extending an Enum
      - Chapter 4. Autoboxing and Unboxing
        Section 4.1. Converting Primitives to Wrapper Types
        Section 4.2. Converting Wrapper Types to Primitives
        Section 4.3. Incrementing and Decrementing Wrapper Types
        Section 4.4. Boolean Versus boolean
        Section 4.5. Conditionals and Unboxing
        Section 4.6. Control Statements and Unboxing
        Section 4.7. Method Overload Resolution
      - Chapter 5. varargs
        Section 5.1. Creating a Variable-Length Argument List
        Section 5.2. Iterating Over Variable-Length Argument Lists
        Section 5.3. Allowing Zero-Length Argument Lists
        Section 5.4. Specify Object Arguments Over Primitives
        Section 5.5. Avoiding Automatic Array Conversion
      - Chapter 6. Annotations
        Section 6.1. Using Standard Annotation Types
        Section 6.2. Annotating an Overriding Method
        Section 6.3. Annotating a Deprecated Method
        Section 6.4. Suppressing Warnings
        Section 6.5. Creating Custom Annotation Types
        Section 6.6. Annotating Annotations
        Section 6.7. Defining an Annotation Type's Target
        Section 6.8. Setting the Retention of an Annotation Type
        Section 6.9. Documenting Annotation Types
        Section 6.10. Setting Up Inheritance in Annotations
        Section 6.11. Reflecting on Annotations
      - Chapter 7. The for/in Statement
        Section 7.1. Ditching Iterators
        Section 7.2. Iterating over Arrays
        Section 7.3. Iterating over Collections
        Section 7.4. Avoiding Unnecessary Typecasts
        Section 7.5. Making Your Classes Work with for/in
        Section 7.6. Determining List Position and Variable Value
        Section 7.7. Removing List Items in a for/in Loop
      - Chapter 8. Static Imports
        Section 8.1. Importing Static Members
        Section 8.2. Using Wildcards in Static Imports
        Section 8.3. Importing Enumerated Type Values
        Section 8.4. Importing Multiple Members with the Same Name
        Section 8.5. Shadowing Static Imports
      - Chapter 9. Formatting
        Section 9.1. Creating a Formatter
        Section 9.2. Writing Formatted Output
        Section 9.3. Using the format( ) Convenience Method
        Section 9.4. Using the printf( ) Convenience Method
      - Chapter 10. Threading
        Section 10.1. Handling Uncaught Exceptions in Threads
        Section 10.2. Using Thread-Safe Collections
        Section 10.3. Using Blocking Queues
        Section 10.4. Specifying Timeouts for Blocking
        Section 10.5. Separating Thread Logic from Execution Logic
        Section 10.6. Using Executor as a Service
        Section 10.7. Using Callable Objects
        Section 10.8. Executing Tasks Without an ExecutorService
        Section 10.9. Scheduling Tasks
        Section 10.10. Advanced Synchronizing
        Section 10.11. Using Atomic Types
        Section 10.12. Locking Versus Synchronization
    - THE Java™ Programming Language, Fourth Edition by Ken Arnold, James Gosling, David Holmes Publisher: Prentice Hall Pub Date: August 17, 2005 Print ISBN-10: 0-321-34980-6 Print ISBN-13: 978-0-321-34980-4 Pages: 928
      - Chapter 1. A Quick Tour
        Section 1.1. Getting Started
        Section 1.2. Variables
        Section 1.3. Comments in Code
        Section 1.4. Named Constants
        Section 1.5. Unicode Characters
        Section 1.6. Flow of Control
        Section 1.7. Classes and Objects
        Section 1.8. Methods and Parameters
        Section 1.9. Arrays
        Section 1.10. String Objects
        Section 1.11. Extending a Class
        Section 1.12. Interfaces
        Section 1.13. Generic Types
        Section 1.14. Exceptions
        Section 1.15. Annotations
        Section 1.16. Packages
        Section 1.17. The Java Platform
        Section 1.18. Other Topics Briefly Noted
      - Chapter 2. Classes and Objects
        Section 2.1. A Simple Class
        Section 2.2. Fields
        Section 2.3. Access Control
        Section 2.4. Creating Objects
        Section 2.5. Construction and Initialization
        Section 2.6. Methods
        Section 2.7. this
        Section 2.8. Overloading Methods
        Section 2.9. Importing Static Member Names
        Section 2.10. The main Method
        Section 2.11. Native Methods
      - Chapter 3. Extending Classes
        Section 3.1. An Extended Class
        Section 3.2. Constructors in Extended Classes
        Section 3.3. Inheriting and Redefining Members
        Section 3.4. Type Compatibility and Conversion
        Section 3.5. What protected Really Means
        Section 3.6. Marking Methods and Classes final
        Section 3.7. Abstract Classes and Methods
        Section 3.8. The Object Class
        Section 3.9. Cloning Objects
        Section 3.10. Extending Classes: How and When
        Section 3.11. Designing a Class to Be Extended
        Section 3.12. Single Inheritance versus Multiple Inheritance
      - Chapter 4. Interfaces
        Section 4.1. A Simple Interface Example
        Section 4.2. Interface Declarations
        Section 4.3. Extending Interfaces
        Section 4.4. Working with Interfaces
        Section 4.5. Marker Interfaces
        Section 4.6. When to Use Interfaces
      - Chapter 5. Nested Classes and Interfaces
        Section 5.1. Static Nested Types
        Section 5.2. Inner Classes
        Section 5.3. Local Inner Classes
        Section 5.4. Anonymous Inner Classes
        Section 5.5. Inheriting Nested Types
        Section 5.6. Nesting in Interfaces
        Section 5.7. Implementation of Nested Types
      - Chapter 6. Enumeration Types
        Section 6.1. A Simple Enum Example
        Section 6.2. Enum Declarations
        Section 6.3. Enum Constant Declarations
        Section 6.4. java.lang.Enum
        Section 6.5. To Enum or Not
      - Chapter 7. Tokens, Values, and Variables
        Section 7.1. Lexical Elements
        Section 7.2. Types and Literals
        Section 7.3. Variables
        Section 7.4. Array Variables
        Section 7.5. The Meanings of Names
      - Chapter 8. Primitives as Types
        Section 8.1. Common Fields and Methods
        Section 8.2. Void
        Section 8.3. Boolean
        Section 8.4. Number
        Section 8.5. Character
        Section 8.6. Boxing Conversions
      - Chapter 9. Operators and Expressions
        Section 9.1. Arithmetic Operations
        Section 9.2. General Operators
        Section 9.3. Expressions
        Section 9.4. Type Conversions
        Section 9.5. Operator Precedence and Associativity
        Section 9.6. Member Access
      - Chapter 10. Control Flow
        Section 10.1. Statements and Blocks
        Section 10.2. if–else
        Section 10.3. switch
        Section 10.4. while and do–while
        Section 10.5. for
        Section 10.6. Labels
        Section 10.7. break
        Section 10.8. continue
        Section 10.9. return
        Section 10.10. What, No goto?
      - Chapter 11. Generic Types
        Section 11.1. Generic Type Declarations
        Section 11.2. Working with Generic Types
        Section 11.3. Generic Methods and Constructors
        Section 11.4. Wildcard Capture
        Section 11.5. Under the Hood: Erasure and Raw Types
        Section 11.6. Finding the Right Method — Revisited
        Section 11.7. Class Extension and Generic Types
      - Chapter 12. Exceptions and Assertions
        Section 12.1. Creating Exception Types
        Section 12.2. throw
        Section 12.3. The throws Clause
        Section 12.4. try, catch, and finally
        Section 12.5. Exception Chaining
        Section 12.6. Stack Traces
        Section 12.7. When to Use Exceptions
        Section 12.8. Assertions
        Section 12.9. When to Use Assertions
        Section 12.10. Turning Assertions On and Off
      - Chapter 13. Strings and Regular Expressions
        Section 13.1. Character Sequences
        Section 13.2. The String Class
        Section 13.3. Regular Expression Matching
        Section 13.4. The StringBuilder Class
        Section 13.5. Working with UTF-16
      - Chapter 14. Threads
        Section 14.1. Creating Threads
        Section 14.2. Using Runnable
        Section 14.3. Synchronization
        Section 14.4. wait, notifyAll, and notify
        Section 14.5. Details of Waiting and Notification
        Section 14.6. Thread Scheduling
        Section 14.7. Deadlocks
        Section 14.8. Ending Thread Execution
        Section 14.9. Ending Application Execution
        Section 14.10. The Memory Model: Synchronization and volatile
        Section 14.11. Thread Management, Security, and ThreadGroup
        Section 14.12. Threads and Exceptions
        Section 14.13. ThreadLocal Variables
        Section 14.14. Debugging Threads
      - Chapter 15. Annotations
        Section 15.1. A Simple Annotation Example
        Section 15.2. Annotation Types
        Section 15.3. Annotating Elements
        Section 15.4. Restricting Annotation Applicability
        Section 15.5. Retention Policies
        Section 15.6. Working with Annotations
      - Chapter 16. Reflection
        Section 16.1. The Class Class
        Section 16.2. Annotation Queries
        Section 16.3. The Modifier Class
        Section 16.4. The Member classes
        Section 16.5. Access Checking and AccessibleObject
        Section 16.6. The Field Class
        Section 16.7. The Method Class
        Section 16.8. Creating New Objects and the Constructor Class
        Section 16.9. Generic Type Inspection
        Section 16.10. Arrays
        Section 16.11. Packages
        Section 16.12. The Proxy Class
        Section 16.13. Loading Classes
        Section 16.14. Controlling Assertions at Runtime
      - Chapter 17. Garbage Collection and Memory
        Section 17.1. Garbage Collection
        Section 17.2. A Simple Model
        Section 17.3. Finalization
        Section 17.4. Interacting with the Garbage Collector
        Section 17.5. Reachability States and Reference Objects
      - Chapter 18. Packages
        Section 18.1. Package Naming
        Section 18.2. Type Imports
        Section 18.3. Package Access
        Section 18.4. Package Contents
        Section 18.5. Package Annotations
        Section 18.6. Package Objects and Specifications
      - Chapter 19. Documentation Comments
        Section 19.1. The Anatomy of a Doc Comment
        Section 19.2. Tags
        Section 19.3. Inheriting Method Documentation Comments
        Section 19.4. A Simple Example
        Section 19.5. External Conventions
        Section 19.6. Notes on Usage
      - Chapter 20. The I/O Package
        Section 20.1. Streams Overview
        Section 20.2. Byte Streams
        Section 20.3. Character Streams
        Section 20.4. InputStreamReader and OutputStreamWriter
        Section 20.5. A Quick Tour of the Stream Classes
        Section 20.6. The Data Byte Streams
        Section 20.7. Working with Files
        Section 20.8. Object Serialization
        Section 20.9. The IOException Classes
        Section 20.10. A Taste of New I/O
      - Chapter 21. Collections
        Section 21.1. Collections
        Section 21.2. Iteration
        Section 21.3. Ordering with Comparable and Comparator
        Section 21.4. The Collection Interface
        Section 21.5. Set and SortedSet
        Section 21.6. List
        Section 21.7. Queue
        Section 21.8. Map and SortedMap
        Section 21.9. enum Collections
        Section 21.10. Wrapped Collections and the Collections Class
        Section 21.11. Synchronized Wrappers and Concurrent Collections
        Section 21.12. The Arrays Utility Class
        Section 21.13. Writing Iterator Implementations
        Section 21.14. Writing Collection Implementations
        Section 21.15. The Legacy Collection Types
        Section 21.16. Properties
      - Chapter 22. Miscellaneous Utilities
        Section 22.1. Formatter
        Section 22.2. BitSet
        Section 22.3. Observer/Observable
        Section 22.4. Random
        Section 22.5. Scanner
        Section 22.6. StringTokenizer
        Section 22.7. Timer and TimerTask
        Section 22.8. UUID
        Section 22.9. Math and StrictMath
      - Chapter 23. System Programming
        Section 23.1. The System Class
        Section 23.2. Creating Processes
        Section 23.3. Shutdown
        Section 23.4. The Rest of Runtime
        Section 23.5. Security
      - Chapter 24. Internationalization and Localization
        Section 24.1. Locale
        Section 24.2. Resource Bundles
        Section 24.3. Currency
        Section 24.4. Time, Dates, and Calendars
        Section 24.5. Formatting and Parsing Dates and Times
        Section 24.6. Internationalization and Localization for Text
      - Chapter 25. Standard Packages
        Section 25.1. java.awt — The Abstract Window Toolkit
        Section 25.2. java.applet — Applets
        Section 25.3. java.beans — Components
        Section 25.4. java.math — Mathematics
        Section 25.5. java.net — The Network
        Section 25.6. java.rmi — Remote Method Invocation
        Section 25.7. java.security and Related Packages — Security Tools
        Section 25.8. java.sql — Relational Database Access
        Section 25.9. Utility Subpackages
        Section 25.10. javax.* — Standard Extensions
        Section 25.11. javax.accessibility — Accessibility for GUIs
        Section 25.12. javax.naming — Directory and Naming Services
        Section 25.13. javax.sound — Sound Manipulation
        Section 25.14. javax.swing — Swing GUI Components
        Section 25.15. org.omg.CORBA — CORBA APIs
      - Appendix A. Application Evolution
        Section A.1. Language, Library, and Virtual Machine Versions
        Section A.2. Dealing with Multiple Dialects
        Section A.3. Generics: Reification, Erasure, and Raw Types
      - Appendix B. Useful Tables
      - Further Reading
        Java Platform Topics
        Object-Oriented Design
        Multithreaded Programming
        Generics
        Regular Expressions
        General Programming Techniques
        Related Languages
        Software Engineering
        Visual Design & GUI Design
      - Colophon
        Note to Translators
      - Article
      - Exercises
      - Quotes
    - Java Enterprise in a Nutshell, 3rd Edition
      - Part I: The Java Enterprise APIs
        Chapter 1. Introduction
        Section 1.1. Enterprise Computing Defined
        Section 1.2. Enterprise Computing Demystified
        Section 1.3. Standard Java Enterprise APIs
        Section 1.4. De Facto Standard Enterprise Development Tools
        Section 1.5. An Enterprise Computing Scenario
        Section 1.6. Other Enterprise APIs
        Chapter 2. Application Assembly and Deployment
        Section 2.1. J2EE Application Assembly Model
        Section 2.2. Component Modules
        Section 2.3. Application Assemblies
        Section 2.4. Deploying J2EE Applications
        Chapter 3. Java Servlets
        Section 3.1. Getting a Servlet Environment
        Section 3.2. Servlet Basics
        Section 3.3. Web Applications
        Section 3.4. Servlet Requests
        Section 3.5. Servlet Responses
        Section 3.6. Custom Servlet Initialization
        Section 3.7. Security
        Section 3.8. Servlet Filters
        Section 3.9. Thread Safety
        Section 3.10. Cookies
        Section 3.11. Session Tracking
        Section 3.12. Databases and Non-HTML Content
        Chapter 4. JavaServer Pages
        Section 4.1. JSP Basics
        Section 4.2. JSP Actions
        Section 4.3. The JSP Expression Language
        Section 4.4. JSP Standard Tag Library
        Section 4.5. Custom Tags
        Section 4.6. Wrapping Up
        Chapter 5. JavaServer Faces
        Section 5.1. The Sample Application
        Section 5.2. Structure of a JSF Application
        Section 5.3. Managed Beans
        Section 5.4. The JSF Expression Language
        Section 5.5. JSF Actions and Views
        Section 5.6. Building Tables
        Section 5.7. Validation
        Section 5.8. Moving on with JSF
        Chapter 6. Enterprise JavaBeans
        Section 6.1. What Version Is Covered Here?
        Section 6.2. EJB Component Model Overview
        Section 6.3. EJB Tutorial
        Section 6.4. Deploying EJBs
        Section 6.5. Using Enterprise JavaBeans
        Section 6.6. Session Bean Specifics
        Section 6.7. Entity Beans
        Section 6.8. Message-Driven Beans
        Section 6.9. Transaction Management
        Section 6.10. EJB 3.0
        Chapter 7. Java and XML
        Section 7.1. Using XML Documents
        Section 7.2. Java API for XML Processing
        Section 7.3. SAX
        Section 7.4. DOM
        Section 7.5. XSLT
        Chapter 8. JDBC
        Section 8.1. JDBC Architecture
        Section 8.2. Connecting to the Database
        Section 8.3. Statements
        Section 8.4. Results
        Section 8.5. Handling Errors
        Section 8.6. Prepared Statements
        Section 8.7. BLOBs and CLOBs
        Section 8.8. Metadata
        Section 8.9. Transactions
        Section 8.10. Stored Procedures
        Section 8.11. Escape Sequences
        Section 8.12. RowSets
        Chapter 9. JNDI
        Section 9.1. JNDI Architecture
        Section 9.2. A Simple Example
        Section 9.3. Introducing the Context
        Section 9.4. Looking Up Objects in a Context
        Section 9.5. The NamingShell Application
        Section 9.6. Listing the Children of a Context
        Section 9.7. Creating and Destroying Contexts
        Section 9.8. Binding Objects
        Section 9.9. Accessing Directory Services
        Section 9.10. Modifying Directory Entries
        Section 9.11. Creating Directory Entries
        Section 9.12. Searching a Directory
        Section 9.13. Event Notification
        Chapter 10. J2EE Security
        Section 10.1. Basic Security Concepts
        Section 10.2. A Look at Java and J2EE Security Standards
        Section 10.3. Declarative Security Versus Programmatic Security
        Section 10.4. Web Component Security
        Section 10.5. EJB Component Security
        Section 10.6. Other J2EE Security Topics
        Section 10.7. Limitations of J2EE Security
        Chapter 11. Java Message Service
        Section 11.1. JMS in the J2EE Environment
        Section 11.2. Elements of Messaging with JMS
        Section 11.3. The Anatomy of Messages
        Section 11.4. Point-to-Point Messaging
        Section 11.5. Publish-Subscribe Messaging
        Section 11.6. Unified Messaging
        Section 11.7. Transactional Messaging
        Chapter 12. Web Services with JAX-RPC and SAAJ
        Section 12.1. What's Covered Here?
        Section 12.2. Brief Introduction to Web Services
        Section 12.3. Java Web Services
        Section 12.4. Writing Web Service Clients
        Section 12.5. Writing Web Services
        Section 12.6. Deploying Web Services
        Chapter 13. Remote Method Invocation
        Section 13.1. What's Covered Here?
        Section 13.2. Introduction to RMI
        Section 13.3. Defining Remote Objects
        Section 13.4. Creating the Stubs and Skeletons
        Section 13.5. Accessing Remote Objects as a Client
        Section 13.6. Dynamic Classloading
        Section 13.7. Remote Object Activation
        Section 13.8. RMI and Native Method Calls
        Section 13.9. RMI Over IIOP
        Chapter 14. Java IDL (CORBA)
        Section 14.1. A Note on Evolving Standards
        Section 14.2. The CORBA Architecture
        Section 14.3. Creating CORBA Objects
        Section 14.4. Putting It in the Public Eye
        Section 14.5. Finding and Using Remote Objects
        Section 14.6. What If I Don't Have the Interface?
        Chapter 15. JavaMail
        Section 15.1. Email and JavaMail
        Section 15.2. Creating and Sending Messages
        Section 15.3. Retrieving Messages
        Section 15.4. Multipart Messages
        Chapter 16. Transactions
        Section 16.1. Transaction Overview
        Section 16.2. Programmatic Transactions Versus Declarative Transactions
        Section 16.3. Optimistic Concurrency
        Section 16.4. EJB Transaction Management
        Section 16.5. Some Common Programming Scenarios
        Section 16.6. Transaction Best Practices
      - Part II: Open Source Enterprise Tools
        Chapter 17. Ant
        Section 17.1. What Version Is Covered Here?
        Section 17.2. Ant Overview
        Section 17.3. Ant Fundamentals
        Section 17.4. Core Tasks
        Section 17.5. Enterprise Tasks
        Section 17.6. Creating Portable Build Processes
        Chapter 18. JUnit and Cactus
        Section 18.1. What's Covered Here?
        Section 18.2. Unit Testing Concepts
        Section 18.3. JUnit Overview
        Section 18.4. Using JUnit with Ant
        Section 18.5. Testing Enterprise Components with Cactus
        Chapter 19. Struts
        Section 19.1. The Scope of Struts
        Section 19.2. The Sample Application
        Section 19.3. The Development Process with Struts
        Section 19.4. The Struts Controller
        Section 19.5. The Action Class
        Section 19.6. Views in Struts
        Section 19.7. Struts Tags
        Section 19.8. Struts Plug-ins
        Section 19.9. DynaActionForms and the Struts Validator
        Chapter 20. Hibernate
        Section 20.1. The Sample Application
        Section 20.2. Principles of Hibernate
        Section 20.3. Configuration and Mapping
        Section 20.4. The Hibernate API
        Section 20.5. HQL (Hibernate Query Language)
        Section 20.6. Hibernate Services
        Section 20.7. Conclusion
        Chapter 21. Annotations with XDoclet and J2SE Metadata
        Section 21.1. What's Covered Here?
        Section 21.2. What Are Code Annotations?
        Section 21.3. Annotation Tools
        Section 21.4. XDoclet Tutorial
        Section 21.5. J2SE Annotations Tutorial
      - Part III: Appendixes
        Appendix A. J2EE Deployment Descriptor Reference
        Section A.1. Web Components (web.xml)
        Section A.2. Enterprise JavaBeans (ejb-jar.xml)
        Section A.3. Application Archives (application .xml)
        Section A.4. Web Services (webservices.xml)
        Section A.5. Web Service Java/WSDL Mappings
        Appendix B. JavaServer Faces Tag Libraries
        Section B.1. JSF Core Tags
        Section B.2. JSF HTML Tags
        Appendix C. Enterprise JavaBeans Query Language Syntax
        Section C.1. Basic Structure of EJB QL Queries
        Section C.2. FROM Clause
        Section C.3. SELECT Clause
        Section C.4. WHERE Clause
        Section C.5. ORDER BY Clause
        Appendix D. SQL Reference
        Section D.1. Relational Databases
        Section D.2. Data Types
        Section D.3. Schema Manipulation Commands
        Section D.4. Data Manipulation Commands
        Section D.5. Functions
        Section D.6. Return Codes
        Appendix E. JMS Message Selector Syntax
        Section E.1. Structure of a Selector
        Section E.2. Identifiers
        Section E.3. Literals
        Section E.4. Operators
        Section E.5. Expressions
        Appendix F. FRMI Tools
        rmic: The Java RMI Compiler
        rmid: The RMI Activation Daemon
        rmiregistry: The Java RMI Object Registry
        serialver: The RMI Serial Version Utility
        Appendix G. IDL Reference
        Section G.1. IDL Keywords
        Section G.2. Identifiers
        Section G.3. Comments
        Section G.4. Basic Data Types
        Section G.5. Constants and Literals
        Section G.6. Naming Scopes
        Section G.7. User-Defined Data Types
        Section G.8. Exceptions
        Section G.9. Module Declarations
        Section G.10. Interface Declarations
        Section G.11. Value Type Declarations
        Appendix H. HJava IDL Tools
        idlj: The Java IDL Compiler
        orbd: Naming Service Daemon
        servertool
        tnameserv: Transient Naming Service Daemon
    - Killer Game Programming in Java
      - Chapter 1. Why Java for Games Programming?
        Section 1.1. Java Is Too Slow for Games Programming
        Section 1.2. Java Has Memory Leaks
        Section 1.3. Java Is Too High-level
        Section 1.4. Java Application Installation Is a Nightmare
        Section 1.5. Java Isn't Supported on Games Consoles
        Section 1.6. No One Uses Java to Write Real Games
        Section 1.7. Sun Microsystems Isn't Interested in Supporting Java Gaming
      - Chapter 2. An Animation Framework
        Section 2.1. Animation as a Threaded Canvas
        Section 2.3. Converting to Active Rendering
        Section 2.4. FPS and Sleeping for Varying Times
        Section 2.5. Sleeping Better
        Section 2.6. FPS and UPS
        Section 2.7. Pausing and Resuming
        Section 2.8. Other Animation Approaches
      - Chapter 3. Worms in Windows and Applets
        Section 3.1. Preliminary Considerations
        Section 3.2. Class Diagrams for the WormChase Application
        Section 3.3. The Worm-Chasing Application
        Section 3.4. The Game Panel
        Section 3.5. Storing Worm Information
        Section 3.6. Worm Obstacles
        Section 3.7. Application Timing Results
        Section 3.8. WormChase as an Applet
        Section 3.9. Compilation in J2SE 5.0
      - Chapter 4. Full-Screen Worms
        Section 4.1. An Almost Full-Screen (AFS) Worm
        Section 4.2. An Undecorated Full-Screen (UFS) Worm
        Section 4.3. A Full-Screen Exclusive Mode (FSEM) Worm
        Section 4.4. Timings at 80 to 85 FPS
      - Chapter 5. An Introduction to Java Imaging
        Section 5.1. Image Formats
        Section 5.2. The AWT Imaging Model
        Section 5.3. An Overview of Java 2D
        Section 5.4. Buffering an Image
        Section 5.5. Managed Images
        Section 5.6. VolatileImage
        Section 5.7. Java 2D Speed
        Section 5.8. Portability and Java 2D
        Section 5.9. JAI
      - Chapter 6. Image Loading, Visual Effects, and Animation
        Section 6.1.
        Section 6.2. Loading Images
        Section 6.3. Applying Image Effects
        Section 6.4. Displaying Image Sequences
        Section 6.5. Visual Effects for 'o' Images
        Section 6.6. Packaging the Application as a JAR
      - Chapter 7. Introducing Java Sound
        Section 7.1. Applet Playing
        Section 7.2. The AudioClip Class
        Section 7.3. The Sound Player
        Section 7.4. The Java Sound API
        Section 7.5. Sampled Audio
        Section 7.6. MIDI
        Section 7.7. Java Sound API Compared with JMF and JOAL
        Section 7.8. Java Sound API Resources
        Section 7.9. Audio Resources
      - Chapter 8. Loading and Playing Sounds
        Section 8.1. Loader Design and Implementation Issues
        Section 8.2. Testing the Loaders
        Section 8.3. The Sounds Panel
        Section 8.4. The Clips Loader
        Section 8.5. Storing Clip Information
        Section 8.6. The Midi Sequences Loader
        Section 8.7. Storing Midi Information
        Section 8.8. LoadersTests as a JAR File
      - Chapter 9. Audio Effects
        Section 9.1. Audio Effects on Sampled Audio
        Section 9.2. Audio Effects on MIDI Sequences
      - Chapter 10. Audio Synthesis
        Section 10.1. Sampled Audio Synthesis
        Section 10.2. MIDI Synthesis
        Section 10.3. Audio Synthesis Libraries
      - Chapter 11. Sprites
        Section 11.1. Bats, Balls, and Sprites
        Section 11.2. Class Diagrams for BugRunner
        Section 11.3. The Bug Starts Running
        Section 11.4. The Animation Framework
        Section 11.5. Defining a Sprite
        Section 11.6. Coding a Sprite
        Section 11.7. Specifying a Sprite with a Statechart
        Section 11.8. The Ball Sprite
        Section 11.9. Defining the Bat
      - Chapter 12. A Side-Scroller
        Section 12.1. JumpingJack in Layers
        Section 12.2. Class Diagrams for JumpingJack
        Section 12.3. Start Jack Jumping
        Section 12.4. The Animation Framework
        Section 12.5. Managing the Ribbons
        Section 12.6. Wraparound Ribbons
        Section 12.7. Managing the Bricks
        Section 12.8. Storing Brick Information
        Section 12.9. The Fireball
        Section 12.10. The Jumping Sprite
        Section 12.11. Other Side-Scroller Examples
        Section 12.12. Tiling Software
      - Chapter 13. An Isometric Tile Game
        Section 13.1. Isometric Tiles
        Section 13.2. Class Diagrams for AlienTiles
        Section 13.3. The Animation Framework
        Section 13.4. Managing the World
        Section 13.5. Managing WorldItems
        Section 13.6. The Tile Occupier
        Section 13.7. A Sprite on a Tile
        Section 13.8. The Player Sprite
        Section 13.9. The Alien Sprite
        Section 13.10. The Quadrant-Based Alien Sprite
        Section 13.11. The A*-Based Alien Sprite
        Section 13.12. Storing Tile Details
        Section 13.13. Further Reading
      - Chapter 14. Introducing Java 3D
        Section 14.1. Java 3D
        Section 14.2. Java 3D Strengths
        Section 14.3. Criticisms of Java 3D for Games Programming
        Section 14.4. Alternatives to Java 3D
      - Chapter 15. A 3D Checkerboard: Checkers3D
        Section 15.1. Class Diagrams for Checkers3D
        Section 15.2. Integrating Java 3D and Swing
        Section 15.3. Scene Graph Creation
        Section 15.4. Floating Spheres
        Section 15.5. The Floor
        Section 15.6. Viewer Positioning
        Section 15.7. Viewer Movement
        Section 15.8. Viewing the Scene Graph
      - Chapter 16. Loading and Manipulating External Models
        Section 16.1. An Overview of LoaderInfo3D
        Section 16.2. Loaders in Java 3D
        Section 16.3. Displaying a Model
        Section 16.4. Examining a Model's Scene Graph
        Section 16.5. Adjusting a Model's Shape Attributes
        Section 16.6. An Overview of Loader3D
        Section 16.7. Using Loader3D
        Section 16.8. Creating the Scene
        Section 16.9. Managing the Model
        Section 16.10. Building the Model's Scene Graph
      - Chapter 17. Using a Lathe to Make Shapes
        Section 17.1. Class Diagrams for Lathe3D
        Section 17.2. Creating the Scene
        Section 17.3. The Lathe Curve
        Section 17.4. The Lathe Shape
        Section 17.5. Subclassing the Lathe Shape
      - Chapter 18. 3D Sprites
        Section 18.1. Class Diagrams for Tour3D
        Section 18.2. Creating the Scene
        Section 18.3. The Basic 3D Sprite
        Section 18.4. The User's Touring Sprite
        Section 18.5. The Alien Sprite
        Section 18.6. Behaviors in Java 3D
        Section 18.7. Controlling the Touring Sprite
        Section 18.8. Updating the Alien Sprite
      - Chapter 19. Animated 3D Sprites
        Section 19.1.
        Section 19.2. Class Diagrams for AnimTour3D
        Section 19.3. Creating the Scene
        Section 19.4. The Animated 3D Sprite
        Section 19.5. Controlling the Sprite
        Section 19.6. Animating the Sprite
        Section 19.7. Full-Screen Exclusive Mode (FSEM)
        Section 19.8. A Full-Screen Version of the Application
        Section 19.9. Pros and Cons of Keyframe Animation
      - Chapter 20. An Articulated, Moveable Figure
        Section 20.1. The Articulated Figure Application
        Section 20.2. Forward and Inverse Kinematics
        Section 20.3. Class Diagrams for Mover3D
        Section 20.4. Creating the Scene
        Section 20.5. Processing User Input
        Section 20.6. The Commands Panel
        Section 20.7. Making and Moving the Figure
        Section 20.8. Modeling a Limb
        Section 20.9. Moving a Limb
        Section 20.10. Other Articulated Figures
        Section 20.11. Articulation and Mesh Deformation
        Section 20.12. Articulation and Skinning
        Section 20.13. Articulation and Morphing
      - Chapter 21. Particle Systems
        Section 21.1. Particle Systems in Java 3D
        Section 21.2. Class Diagrams for Particles3D
        Section 21.3. Creating the Scene
        Section 21.4. A Fountain of Points
        Section 21.5. A Fountain of Lines
        Section 21.6. A Fountain of Quads
        Section 21.7. Performance Results
        Section 21.8. More Particle Systems
        Section 21.9. Other Java 3D Approaches
        Section 21.10. Non-Java 3D Approaches
      - Chapter 22. Flocking Boids
        Section 22.1. A Flocking Application
        Section 22.2. Scene Creation
        Section 22.3. Adding Obstacles
        Section 22.4. Types of Boids
        Section 22.5. Grouping the Boids
        Section 22.6. Flock Behavior
      - Chapter 23. Shooting a Gun
        Section 23.1. Class Diagrams for Shooter3D
        Section 23.2. Scene Creation
        Section 23.3. The Sound of Shooting
        Section 23.4. Picking Scene Objects
        Section 23.5. Controlling the Gun
        Section 23.6. Preparing the Laser Beam
        Section 23.7. Causing an Explosion
        Section 23.8. Picking with a Mouse Click
        Section 23.9. Shooting Behavior
        Section 23.10. Firing the Beam
        Section 23.11. More on Picking
      - Chapter 24. A First-Person Shooter
        Section 24.1. Class Diagrams for FPShooter3D
        Section 24.2. Setting Up the Target
        Section 24.3. Positioning and Moving the User's Viewpoint
        Section 24.4. Initializing the User's Viewpoint
        Section 24.5. Adding an Image to the Viewpoint
        Section 24.6. Managing the Ammunition
        Section 24.7. Managing a Laser Beam
        Section 24.8. Moving the Viewpoint
      - Chapter 25. A 3D Maze
        Section 25.1. Class Diagrams for Maze3D
        Section 25.2. Making a Maze Plan
        Section 25.3. The User Interface
        Section 25.4. Managing the Maze
        Section 25.5. Scenery Creation
        Section 25.6. Tiling the Floor
        Section 25.7. Viewpoint Creation
        Section 25.8. The Back Facing Camera
        Section 25.9. Moving the Viewpoint
        Section 25.10. The Bird's-Eye View
        Section 25.11. Related Approaches to Scene Generation
      - Chapter 26. Fractal Land
        Section 26.1. Class Diagrams for the Fractal Land
        Section 26.2. Building the Fractal Land
        Section 26.3. Creating the Landscape
        Section 26.4. Constructing the Ground
        Section 26.5. Generating a Fractal Landscape
        Section 26.6. Responding to Key Presses
        Section 26.7. Terrain Following and Collision Avoidance
        Section 26.8. Placing Objects in the Scene
        Section 26.9. Other Fractal Landscapes
      - Chapter 27. Terrain Generation with Terragen
        Section 27.1. Class Diagrams for Terra3D
        Section 27.2. Terragen
        Section 27.3. Scenery Creation
        Section 27.4. Building the Landscape
        Section 27.5. Making 3D Scenery
        Section 27.6. Adding Landscape Walls
        Section 27.7. Creating Ground Cover
        Section 27.8. Moving over the Surface
        Section 27.9. Finding the Surface Height
        Section 27.10. Accelerating Terrain Following
        Section 27.11. More on Terrain Generation
      - Chapter 28. Trees That Grow
        Section 28.1. Class Diagrams for Trees3D
        Section 28.2. Creating the Scene
        Section 28.3. Building a Tree Limb
        Section 28.4. Executing the Rules
        Section 28.5. Displaying Leaves
        Section 28.6. Comparison with L-Systems
      - Chapter 29. Networking Basics
        Section 29.1. The Elements of Network Communication
        Section 29.2. The Client/Server Model
        Section 29.3. The Peer-to-Peer Model
        Section 29.4. Client/Server Programming in Java
        Section 29.5. P2P Programming in Java
        Section 29.6. Firewalls
        Section 29.7. Other Kinds of Java Networking
      - Chapter 30. Network Chat
        Section 30.1. Threaded TCP Clients and Server
        Section 30.2. UDP Multicasting Clients and a Name Server
        Section 30.3. Clients Using a Servlet as a Server
      - Chapter 31. A Networked Two-Person Game
        Section 31.1. The Standalone Tic-Tac-Toe Game
        Section 31.2. The Networked Tic-Tac-Toe Game
        Section 31.3. Comparing NetFourByFour and FourByFour
      - Chapter 32. A Networked Virtual Environment
        Section 32.1. Background on NVEs
        Section 32.2. An Overview of NetTour3D
        Section 32.3. Scene Creation on the Client
        Section 32.4. Defining Sprites
        Section 32.5. Local Sprites
        Section 32.6. Watching the Server
        Section 32.7. Server Activities
        Section 32.8. Other Java NVEs
      - Appendix A. Installation Using install4j
        Section A.1. install4j Versus JWS
        Section A.2. The Java 3D Components
        Section A.3. The BugRunner Application
        Section A.4. The Checkers3D Application
      - Appendix B. Installation Using Java Web Start
        Section B.1. JWS Benefits
        Section B.2. JWS Downsides
        Section B.3. The JNLP Deployment File
        Section B.4. Steps in Developing a JWS Application
        Section B.5. A JWS Installer for BugRunner
        Section B.6. A JWS Installer for Checkers3D
        Section B.7. Another Way to Install Checkers3D
        Section B.8. The JWS Portal Page
        Section B.9. Third-Party Certificates
        Section B.10. More Information
    - Head First Java, 2nd Edition
      - Chapter 1. Breaking the Surface
        Section 1.1. The Way Java Works
        Section 1.2. What you'll do in Java
        Section 1.3. A very brief history of Java
        Section 1.4. Sharpen your pencil
        Section 1.5. Sharpen your pencil answers
        Section 1.6. Code structure in Java
        Section 1.7. Anatomy of a class
        Section 1.8. Writing a class with a main
        Section 1.9. What can you say in the main method?
        Section 1.10. Looping and looping and...
        Section 1.11. there are no Dumb Questions
        Section 1.12. Conditional branching
        Section 1.13. Coding a Serious Business Application
        Section 1.14. Monday morning at Bob's
        Section 1.15. Phrase-O-Matic
        Section 1.16. Fireside Chats
        Section 1.17. Exercise: Code Magnets
        Section 1.18. Exercise: BE The compiler
        Section 1.19. JavaCross 7.0
        Section 1.20. Mixed Messages
        Section 1.21. Pool Puzzle
        Section 1.22. Exercise Solutins: Code Magnets:
      - Chapter 2. A Trip to Objectville
        Section 2.1. Chair Wars
        Section 2.2. Brain Power
        Section 2.3. Making your first object
        Section 2.4. Making and testing Movie objects
        Section 2.5. Quick! Get out of main!
        Section 2.6. Running the Guessing Game
        Section 2.7. Who am I?
      - Chapter 3. Know Your Variables
        Section 3.1. Declaring a variable
        Section 3.2. "I'd like a double mocha, no, make it an int."
        Section 3.3. You really don't want to spill that...
        Section 3.4. Back away from that keyword!
        Section 3.5. This table reserved.
        Section 3.6. Controlling your Dog object
        Section 3.7. An object reference is just another variable value.
        Section 3.8. There are no Dumb Question
        Section 3.9. Java Exposed
        Section 3.10. Life on the garbage-collectible heap
        Section 3.11. Life and death on the heap
        Section 3.12. An array is like a tray of cups
        Section 3.13. Arrays are objects too
        Section 3.14. Make an array of Dogs
        Section 3.15. Control your Dog
        Section 3.16. A Dog example
        Section 3.17. Exercise: BE the compiler
        Section 3.18. Exercise: Code Magnets
        Section 3.19. Pool Puzzle
        Section 3.20. A Heap o' Trouble
        Section 3.21. Five-Minute Mystery
        Section 3.22. Exercise Solutions: Code Magnets
        Section 3.23. Puzzle Solutions
      - Chapter 4. How Objects Behave
        Section 4.1. Remember: a class describes what an object knows and what an object does
        Section 4.2. The size affects the bark
        Section 4.3. You can send things to a method
        Section 4.4. You can get things back from a method.
        Section 4.5. You can send more than one thing to a method
        Section 4.6. there are no Dumb Questions
        Section 4.7. Reminder: Java cares about type!
        Section 4.8. Cool things you can do with parameters and return types
        Section 4.9. Encapsulation
        Section 4.10. Encapsulating the GoodDog class
        Section 4.11. How do objects in an array behave?
        Section 4.12. Declaring and initializing instance variables
        Section 4.13. The difference between instance and local variables
        Section 4.14. there are no Dumb Questions
        Section 4.15. Comparing variables (primitives or references)
        Section 4.16. Exercise: BE the compiler
        Section 4.17. Who am I?
        Section 4.18. Mixed Messages
        Section 4.19. Pool Puzzle
        Section 4.20. Five Minute Mystery
        Section 4.21. Puzzle Solutions
      - Chapter 5. Extra-Strength Methods
        Section 5.1. Let's build a Battleship-style game: "Sink a Dot Com"
        Section 5.2. First, a high-level design
        Section 5.3. The "Simple Dot Com Game" a gentler introduction
        Section 5.4. Developing a Class
        Section 5.5. BRAIN POWER
        Section 5.6. There are no Dumb Questions
        Section 5.7. There are no Dumb Questions
        Section 5.8. Exercise: BE the JVM
        Section 5.9. Exercise: Code Magnets
        Section 5.10. Java Cross
        Section 5.11. Exercise Solutions
      - Chapter 6. Using the Java Library
        Section 6.1. In our last chapter, we left you with the cliff-hanger. A bug.
        Section 6.2. So what happened?
        Section 6.3. How do we fix it?
        Section 6.4. Option one is too clunky
        Section 6.5. Option two is a little better, but still pretty clunky
        Section 6.6. Wake up and smell the library
        Section 6.7. Some things you can do with ArrayList
        Section 6.8. there are no Dumb Questions
        Section 6.9. Java Exposed
        Section 6.10. Comparing ArrayList to a regular array
        Section 6.11. Comparing ArrayList to a regular array
        Section 6.12. Let's fix the DotCom code.
        Section 6.13. New and improved DotCom class
        Section 6.14. Let's build the REAL game: "Sink a Dot Com"
        Section 6.15. What needs to change?
        Section 6.16. Who does what in the DotComBust game (and when)
        Section 6.17. Prep code for the real DotComBust class
        Section 6.18. The final version of the Dotcom class
        Section 6.19. Super Powerful Boolean Expressions
        Section 6.20. Ready-bake Code
        Section 6.21. Ready-bake Code
        Section 6.22. Using the Library (the Java API)
        Section 6.23. You have to know the full name of the class you want to use in your code.
        Section 6.24. there are no Dumb Questions
        Section 6.25. there are no Dumb Questions
        Section 6.26. How to play with the API
        Section 6.27. Code Magnets
        Section 6.28. JavaCross 7.0
        Section 6.29. Exercise Solutions
        Section 6.30. JavaCross answers
      - Chapter 7. Better Living in Objectville
        Section 7.1. Chair Wars Revisited...
        Section 7.2. BRAIN POWER
        Section 7.3. there are no Dumb Questions
        Section 7.4. there are no Dumb Questions
        Section 7.5. brain power
        Section 7.6. there are no Dumb Questions
        Section 7.7. Exercise: Mixed Messages
        Section 7.8. Exercise BE the Compiler
        Section 7.9. Exercise Solutions: BE the Compiler
      - Chapter 8. Serious Polymorphism
        Section 8.1. Did we forget about something when we designed this?
        Section 8.2. BRAIN POWER
        Section 8.3. there are no Dumb Questions
        Section 8.4. Pool Puzzle
        Section 8.5. Exercise Solutions
      - Chapter 9. Life and Death of an Object
        Section 9.1. The Stack and the Heap: where things live
        Section 9.2. Methods are stacked
        Section 9.3. What about local variables that are objects?
        Section 9.4. there are no Dumb Questions
        Section 9.5. If local variables live on the stack, where do instance variables live?
        Section 9.6. The miracle of object creation
        Section 9.7. Construct a Duck
        Section 9.8. Initializing the state of a new Duck
        Section 9.9. there are no Dumb Questions
        Section 9.10. Using the constructor to initialize important Duck state
        Section 9.11. Make it easy to make a Duck
        Section 9.12. Doesn't the compiler always make a no-arg constructor for you? No!
        Section 9.13. there are no Dumb Questions
        Section 9.14. there are no Dumb Questions
        Section 9.15. Wait a minute... we never DID talk about superclasses and inheritance and how that all fits in with constructors.
        Section 9.16. Making a Hippo means making the Animal and Object parts too...
        Section 9.17. How do you invoke a superclass constructor?
        Section 9.18. Can the child exist before the parents?
        Section 9.19. Superclass constructors with arguments
        Section 9.20. Invoking one overloaded constructor from another
        Section 9.21. Now we know how an object is born, but how long does an object live?
        Section 9.22. What about reference variables?
      - Chapter 10. Numbers Matter
        Section 10.1. MATH methods: as close as you'll ever get to a global method
        Section 10.2. The difference between regular (non-static) and static methods
        Section 10.3. What it means to have a class with static methods.
        Section 10.4. Static methods can't use non-static (instance) variables!
        Section 10.5. Static methods can't use non-static methods, either!
        Section 10.6. Static variable: value is the same for ALL instances of the class
        Section 10.7. Initializing a static variable
        Section 10.8. static final variables are constants
        Section 10.9. final isn't just for static variables...
        Section 10.10. there are no Dumb Questions
        Section 10.11. Math methods
        Section 10.12. Wrapping a primitive
        Section 10.13. Before Java 5.0, YOU had to do the work...
        Section 10.14. Autoboxing: blurring the line bet ween primitive and object
        Section 10.15. Autoboxing works almost everywhere
        Section 10.16. But wait! There's more! Wrappers have static utility methods too!
        Section 10.17. And now in reverse... turning a primitive number into a String
        Section 10.18. Number formatting
        Section 10.19. Formatting deconstructed...
        Section 10.20. The percent (%) says, "insert argument here" (and format it using these instructions)
        Section 10.21. The format String uses its own little language syntax
        Section 10.22. The format specifier
        Section 10.23. The only required specifier is for TYPE
        Section 10.24. What happens if I have more than one argument?
        Section 10.25. So much for numbers, what about dates?
        Section 10.26. Working with Dates
        Section 10.27. Moving backward and for ward in time
        Section 10.28. Getting an object that extends Calendar
        Section 10.29. Working with Calendar objects
        Section 10.30. Highlights of the Calendar API
        Section 10.31. Even more Statics!... static imports
        Section 10.32. Lunar Code Magnets
      - Chapter 11. Risky Behavior
        Section 11.1. Let's make a Music Machine
        Section 11.2. We'll start with the basics
        Section 11.3. First we need a Sequencer
        Section 11.4. Something's wrong!
        Section 11.5. What happens when a method you want to call (probably in a class you didn't write) is risky?
        Section 11.6. Methods in Java use exceptions to tell the calling code, "Some thing Bad Happened. I failed."
        Section 11.7. The compiler needs to know that YOU know you're calling a risky method.
        Section 11.8. An exception is an object… of type Exception.
        Section 11.9. If it's your code that catches the exception, then whose code throws it?
        Section 11.10. there are no Dumb Questions
        Section 11.11. Flow control in try/catch blocks
        Section 11.12. Finally: for the things you want to do no matter what.
        Section 11.13. Sharpen your pencil:Flow Control
        Section 11.14. Did we mention that a method can throw more than one exception?
        Section 11.15. Exceptions are polymorphic
        Section 11.16. Multiple catch blocks must be ordered from smallest to biggest
        Section 11.17. You can't put bigger baskets above smaller baskets.
        Section 11.18. Sharpen your pencil
        Section 11.19. When you don't want to handle an exception…
        Section 11.20. Ducking (by declaring) only delays the inevitable
        Section 11.21. Getting back to our music code…
        Section 11.22. Code Kitchen
        Section 11.23. Making actual sound
        Section 11.24. Your very first sound player app
        Section 11.25. Making a MidiEvent (song data)
        Section 11.26. MIDI message: the heart of a MidiEvent
        Section 11.27. Anatomy of a message
        Section 11.28. Version 2: Using command-line args to experiment with sounds
        Section 11.29. Exercise: True or False
        Section 11.30. Exercise: Code Magnets
        Section 11.31. JavaCross 7.0
        Section 11.32. Exercise Solutions: True or False
        Section 11.33. Code Magnets
        Section 11.34. JavaCross Answers
      - Chapter 12. A Very Graphic
        Section 12.1. It all starts with a window
        Section 12.2. Your first GUI: a button on a frame
        Section 12.3. Getting a user event
        Section 12.4. Getting a button's ActionEvent
        Section 12.5. There are no Dumb Questions
        Section 12.6. Make your own drawing widget
        Section 12.8. BULLET POINTS
        Section 12.9. We can get an event.
        Section 12.10. Let's try it with TWO buttons
        Section 12.11. Java Exposed: This weeks interview: Instance of an Inner Class
        Section 12.12. There are no Dumb Questions
        Section 12.13. Code Kitchen
        Section 12.14. Exercise: Who am I?
        Section 12.15. Exercise: BE the compiler
        Section 12.16. Pool Puzzle
        Section 12.17. Exercise Solutions: Who am I?
        Section 12.18. Pool Puzzle
      - Chapter 13. Work on Your Swing
        Section 13.1. Swing components
        Section 13.2. Layout Managers
        Section 13.3. How does the layout manager decide?
        Section 13.4. The Big Three layout managers: border, flow, and box.
        Section 13.5. there are no Dumb Questions
        Section 13.6. Playing with Swing components
        Section 13.7. there are no Dumb Questions
        Section 13.8. Code Kitchen
        Section 13.9. Making the BeatBox
        Section 13.10. Exercise: Which code goes with which layout?
        Section 13.11. Code Fragments
      - Chapter 14. Saving Objects
        Section 14.1. Capture the Beat
        Section 14.2. Saving State
        Section 14.3. Writing a serialized object to a file
        Section 14.4. Data moves in streams from one place to another
        Section 14.5. What really happens to an object when it's serialized?
        Section 14.6. But what exactly IS an object's state? What needs to be saved?
        Section 14.7. If you want your class to be serializable, implement Serializable
        Section 14.8. There are no Dumb Questions
        Section 14.9. Deserialization: restoring an object
        Section 14.10. What happens during deserialization?
        Section 14.11. There are no Dumb Questions
        Section 14.12. Saving and restoring the game characters
        Section 14.13. The GameCharacter class
        Section 14.14. Object Serialization
        Section 14.15. Writing a String to a Text File
        Section 14.16. Text File Example: e-Flashcards
        Section 14.17. Quiz Card Builder (code outline)
        Section 14.18. The java.io.File class
        Section 14.19. The beauty of buffers
        Section 14.20. Reading from a Text File
        Section 14.21. Quiz Card Player (code outline)
        Section 14.22. Parsing with String split()
        Section 14.23. There are no Dumb Questions
        Section 14.24. Version ID: A Big Serialization Gotcha
        Section 14.25. Using the serialVersionUID
        Section 14.26. Code Kitchen
        Section 14.27. Saving a BeatBox pattern
        Section 14.28. Restoring a BeatBox pattern
        Section 14.29. Sharpen your pencil: Can they be saved?
        Section 14.30. Exercise: True or False
        Section 14.31. Code Magnets
        Section 14.32. Exercise Solutions
      - Chapter 15. Make a Connection
        Section 15.1. Real-time Beat Box Chat
        Section 15.2. Connecting, Sending, and Receiving
        Section 15.3. Make a network Socket connection
        Section 15.4. A TCP port is just a number: A 16-bit number that identifies a specific program on the server.
        Section 15.5. To read data from a Socket, use a BufferedReader
        Section 15.6. To write data to a Socket, use a PrintWriter
        Section 15.7. DailyAdviceClient code
        Section 15.8. Writing a simple server
        Section 15.9. DailyAdviceServer code
        Section 15.10. Writing a Chat Client
        Section 15.11. Java has multiple threads but only one Thread class
        Section 15.12. What does it mean to have more than one call stack?
        Section 15.13. Every Thread needs a job to do: A method to put on the new thread stack.
        Section 15.14. To make a job for your thread, implement the Runnable interface
        Section 15.15. The Thread Scheduler
        Section 15.16. there are no Dumb Questions
        Section 15.17. Putting a thread to sleep
        Section 15.18. Using sleep to make our program more predictable.
        Section 15.19. Making and starting two threads
        Section 15.20. What will happen?
        Section 15.21. Um, yes. There IS a dark side. Threads can lead to concurrency 'issues'.
        Section 15.22. The Ryan and Monica problem, in code
        Section 15.23. The Ryan and Monica example
        Section 15.24. We need the makeWithdrawal ( ) method to run as one atomic thing.
        Section 15.25. Using an object's lock
        Section 15.26. The dreaded "Lost Update" problem
        Section 15.27. Let's run this code...
        Section 15.28. Make the increment() method atomic. Synchronize it!
        Section 15.29. there are no Dumb Questions
        Section 15.30. The deadly side of synchronization
        Section 15.31. New and improved SimpleChatClient
        Section 15.32. Ready-bake Code: The really really simple Chat Server
        Section 15.33. there are no Dumb Questions
        Section 15.34. Code Kitchen
        Section 15.35. Exercise: Code Magnets
        Section 15.36. Exercise Solutions
        Section 15.37. Five-Minute Mystery
      - Chapter 16. Data structures
        Section 16.1. Tracking song popularity on your jukebox
        Section 16.2. Here's what you have so far, without the sort:
        Section 16.3. But the ArrayList class does NOT have a sort() method!
        Section 16.4. ArrayList is not the only collection
        Section 16.5. You could use a TreeSet... Or you could use the Collections.sort() method
        Section 16.6. Adding Collections.sort() to the Jukebox code
        Section 16.7. But now you need Song objects, not just simple Strings.
        Section 16.8. Changing the Jukebox code to use Songs instead of Strings
        Section 16.9. It won't compile!
        Section 16.10. The sort() method declaration
        Section 16.11. Generics means more type-safety
        Section 16.12. Learning generics
        Section 16.13. Using generic CLASSES
        Section 16.14. Using type parameters with ArrayList
        Section 16.15. Using generic METHODS
        Section 16.16. Here's where it gets weird...
        Section 16.17. Revisiting the sort() method
        Section 16.18. In generics, "extends" means "extends or implements"
        Section 16.19. Finally we know what's wrong...
        Section 16.20. The new, improved, comparable Song class
        Section 16.21. We can sort the list, but...
        Section 16.22. Using a custom comparator
        Section 16.23. Updating the Jukebox to use a Comparator
        Section 16.24. Sharpen your pencil: Reverse Engineer
        Section 16.25. Sharpen your pencil: Fill-in-the-blanks
        Section 16.26. Uh-oh. The sorting all works, but now we have duplicates...
        Section 16.27. We need a Set instead of a List
        Section 16.28. The Collection API (part of it)
        Section 16.29. Using a HashSet instead of ArrayList
        Section 16.30. What makes two objects equal?
        Section 16.31. How a HashSet checks for duplicates: hashCode() and equals()
        Section 16.32. The Song class with overridden hashCode() and equals()
        Section 16.33. there are no Dumb Questions
        Section 16.34. And if we want the set to stay sorted, we've got TreeSet
        Section 16.35. What you MUST know about TreeSet...
        Section 16.36. TreeSet elements MUST be comparable
        Section 16.37. We've seen Lists and Sets, now we'll use a Map
        Section 16.38. Finally, back to generics
        Section 16.39. Using polymorphic arguments and generics
        Section 16.40. But will it work with ArrayList<Dog> ?
        Section 16.41. What could happen if it were allowed...
        Section 16.42. Wildcards to the rescue
        Section 16.43. Alternate syntax for doing the same thing
        Section 16.44. there are no Dumb Questions
        Section 16.45. Exercise: BE the compiler, advanced
        Section 16.46. Solution to the "Reverse Engineer" sharpen exercise
        Section 16.47. Exercise Solution
        Section 16.48. BE the compiler solution
      - Chapter 17. Release Your Code
        Section 17.1. Deploying your application
        Section 17.2. Imagine this scenario...
        Section 17.3. Separate source code and class files
        Section 17.4. Put your Java in a JAR
        Section 17.5. Running (executing) the JAR
        Section 17.6. Put your classes in packages!
        Section 17.7. Preventing package name conflicts
        Section 17.8. Compiling and running with packages
        Section 17.9. The -d flag is even cooler then we said
        Section 17.10. Making an executable JAR with packages
        Section 17.11. So where did the manifest file go?
        Section 17.12. Java Web Start
        Section 17.13. The .jnlp file
        Section 17.14. Steps for making and deploying a Java Web Start app
        Section 17.15. What's First?
        Section 17.16. True or False
        Section 17.17. Summary-Cross 7.0
      - Chapter 18. Distributed Computing
        Section 18.1. Method calls are always bet ween two objects on the same heap.
        Section 18.2. What if you want to invoke a method on an object running on another machine?
        Section 18.3. Object A, running on Little, wants to call a method on Object B, running on Big
        Section 18.4. But you can't do that
        Section 18.5. The role of the 'helpers'
        Section 18.6. Java RMI gives you the client and service helper objects!
        Section 18.7. How does the client get the stub object?
        Section 18.8. How does the client get the stub class?
        Section 18.9. Be sure each machine has the class files it needs.
        Section 18.10. Sharpen your pencil: What's First?
        Section 18.11. Yeah, but who really uses RMI?
        Section 18.12. What about Servlets?
        Section 18.13. A very simple Ser vlet
        Section 18.14. HTML page with a link to this servlet
        Section 18.15. There are no Dumb Questions
        Section 18.16. Just for fun, let's make the Phrase-O-Matic work as a servlet
        Section 18.17. Phrase-O-Matic code, servlet-friendly
        Section 18.18. Enterprise JavaBeans: RMI on steroids
        Section 18.19. For our final trick... a little Jini
        Section 18.20. Adaptive discovery in action
        Section 18.21. Self-healing net work in action
        Section 18.22. Final Project: the Universal Service browser
        Section 18.23. How it works:
        Section 18.24. The classes and interfaces:
        Section 18.25. Sharpen your pencil
        Section 18.26. Congratulations!
      - Appendix A. Final Code Kitchen
        Section A.1. Final BeatBox client program
      - Appendix B. The Top Ten Topics that almost made it into the Real Book...
        Section B.1. #10 Bit Manipulation
        Section B.2. #9 Immutability
        Section B.3. #8 Assertions
        Section B.4. #7 Block Scope
        Section B.5. #6 Linked Invocations
        Section B.6. #5 Anonymous and Static Nested Classes
        Section B.7. #5 Anonymous and Static Nested Classes, continued
        Section B.8. #4 Access Levels and Access Modifiers (Who Sees What)
        Section B.9. #4 Access Levels and Access Modifiers, cont.
        Section B.10. #3 String and StringBuffer/StringBuilder Methods
        Section B.11. #2 Multidimensional Arrays
        Section B.12. And the number one topic that didn't quite make it in... #1 Enumerations (also called Enumerated Types or Enums)
        Section B.13. Using "if" and "switch" with Enums
        Section B.14. #1 Enumerations, completed
        Section B.15. Five-Minute Mystery: A Long Trip Home
        Section B.16. Five-Minute Mystery Solution
    - Java For Artists—The Art, Philosophy, and Science of Object-Oriented Programming
      - Preface
      - Part I - The Java Student Survival Guide
        Chapter 1 - An Approach to the Art of Programming
        Chapter 2 - Small Victories: Creating Java Projects
        Chapter 3 - Project Walkthrough: A Complete Example
        Chapter 4 - Computers, Programs, & Algorithms
      - Part II - Language Fundamentals
        Chapter 5 - Overview Of The Java Platform API
        Chapter 6 - Simple Java Programs: Using Primitive And Reference Data Types
        Chapter 7 - Controlling The Flow Of Program Execution
        Chapter 8 - Arrays
        Chapter 9 - Toward Problem Abstraction: Creating New Data Types
        Chapter 10 - Compositional Design
        Chapter 11 - Extending Class Behavior Through Inheritance
      - Part III - Graphical User Interface Programming
        Chapter 12 - Java Swing API Overview
        Chapter 13 - Handling GUI Events
        Chapter 14 - An Advanced GUI Project
      - Part IV - Intermediate Concepts
        Chapter 15 - Exceptions
        Chapter 16 - Threads
        Chapter 17 - Collections
        Chapter 18 - File I/O
      - Part V - Network Programming
        Chapter 19 - Introduction To Networking And Distributed Applications
        Chapter 20 - Client-Server Applications
        Chapter 21 - Applets & JDBC
      - Part VI - Object-Oriented Design
        Chapter 22 - Inheritance, Composition, Interfaces, Polymorphism
        Chapter 23 - Well-Behaved Objects
        Chapter 24 - Three Design Principles
        Chapter 25 - Helpful Design Patterns
      - Appendices
        Appendix A - Helpful Checklists and Tables
        Appendix B - ASCII Table
        Appendix C - Answers to Self Test Questions
      - Index
        List of Figures
        List of Tables
        List of Examples
  - JavaScipt
    - JavaScript: The Definitive Guide, 4th Edition
      - Chapter 1. Introduction to JavaScript
        Section 1.1. JavaScript Myths
        Section 1.2. Versions of JavaScript
        Section 1.3. Client-Side JavaScript
        Section 1.4. JavaScript in Other Contexts
        Section 1.5. Client-Side JavaScript: Executable Content in Web Pages
        Section 1.6. Client-Side JavaScript Features
        Section 1.7. JavaScript Security
        Section 1.8. Example: Computing Loan Payments with JavaScript
        Section 1.9. Using the Rest of This Book
        Section 1.10. Exploring JavaScript
      - Part I: Core JavaScript
        Chapter 2. Lexical Structure
        Section 2.1. Character Set
        Section 2.2. Case Sensitivity
        Section 2.3. Whitespace and Line Breaks
        Section 2.4. Optional Semicolons
        Section 2.5. Comments
        Section 2.6. Literals
        Section 2.7. Identifiers
        Section 2.8. Reserved Words
        Chapter 3. Data Types and Values
        Section 3.1. Numbers
        Section 3.2. Strings
        Section 3.3. Boolean Values
        Section 3.4. Functions
        Section 3.5. Objects
        Section 3.6. Arrays
        Section 3.7. null
        Section 3.8. undefined
        Section 3.9. The Date Object
        Section 3.10. Regular Expressions
        Section 3.11. Error Objects
        Section 3.12. Primitive Data Type Wrapper Objects
        Chapter 4. Variables
        Section 4.1. Variable Typing
        Section 4.2. Variable Declaration
        Section 4.3. Variable Scope
        Section 4.4. Primitive Types and Reference Types
        Section 4.5. Garbage Collection
        Section 4.6. Variables as Properties
        Section 4.7. Variable Scope Revisited
        Chapter 5. Expressions and Operators
        Section 5.1. Expressions
        Section 5.2. Operator Overview
        Section 5.3. Arithmetic Operators
        Section 5.4. Equality Operators
        Section 5.5. Relational Operators
        Section 5.6. String Operators
        Section 5.7. Logical Operators
        Section 5.8. Bitwise Operators
        Section 5.9. Assignment Operators
        Section 5.10. Miscellaneous Operators
        Chapter 6. Statements
        Section 6.1. Expression Statements
        Section 6.2. Compound Statements
        Section 6.3. if
        Section 6.4. else if
        Section 6.5. switch
        Section 6.6. while
        Section 6.7. do/while
        Section 6.8. for
        Section 6.9. for/in
        Section 6.10. Labels
        Section 6.11. break
        Section 6.12. continue
        Section 6.13. var
        Section 6.14. function
        Section 6.15. return
        Section 6.16. throw
        Section 6.17. try/catch/finally
        Section 6.18. with
        Section 6.19. The Empty Statement
        Section 6.20. Summary of JavaScript Statements
        Chapter 7. Functions
        Section 7.1. Defining and Invoking Functions
        Section 7.2. Functions as Data
        Section 7.3. Function Scope: The Call Object
        Section 7.4. Function Arguments: The Arguments Object
        Section 7.5. Function Properties and Methods
        Chapter 8. Objects
        Section 8.1. Objects and Properties
        Section 8.2. Constructors
        Section 8.3. Methods
        Section 8.4. Prototypes and Inheritance
        Section 8.5. Object-Oriented JavaScript
        Section 8.6. Objects as Associative Arrays
        Section 8.7. Object Properties and Methods
        Chapter 9. Arrays
        Section 9.1. Arrays and Array Elements
        Section 9.2. Array Methods
        Chapter 10. Pattern Matching with Regular Expressions
        Section 10.1. Defining Regular Expressions
        Section 10.2. String Methods for Pattern Matching
        Section 10.3. The RegExp Object
        Chapter 11. Further Topics in JavaScript
        Section 11.1. Data Type Conversion
        Section 11.2. By Value Versus by Reference
        Section 11.3. Garbage Collection
        Section 11.4. Lexical Scoping and Nested Functions
        Section 11.5. The Function( ) Constructor and Function Literals
        Section 11.6. Netscape's JavaScript 1.2 Incompatibilities
      - Part II: Client-Side JavaScript
        Chapter 12. JavaScript in Web Browsers
        Section 12.1. The Web Browser Environment
        Section 12.2. Embedding JavaScript in HTML
        Section 12.3. Execution of JavaScript Programs
        Chapter 13. Windows and Frames
        Section 13.1. Window Overview
        Section 13.2. Simple Dialog Boxes
        Section 13.3. The Status Line
        Section 13.4. Timeouts and Intervals
        Section 13.5. Error Handling
        Section 13.6. The Navigator Object
        Section 13.7. The Screen Object
        Section 13.8. Window Control Methods
        Section 13.9. The Location Object
        Section 13.10. The History Object
        Section 13.11. Multiple Windows and Frames
        Chapter 14. The Document Object
        Section 14.1. Document Overview
        Section 14.2. Dynamically Generated Documents
        Section 14.3. Document Color Properties
        Section 14.4. Document Information Properties
        Section 14.5. Forms
        Section 14.6. Images
        Section 14.7. Links
        Section 14.8. Anchors
        Section 14.9. Applets
        Section 14.10. Embedded Data
        Chapter 15. Forms and Form Elements
        Section 15.1. The Form Object
        Section 15.2. Defining Form Elements
        Section 15.3. Scripting Form Elements
        Section 15.4. Form Verification Example
        Chapter 16. Scripting Cookies
        Section 16.1. An Overview of Cookies
        Section 16.2. Storing Cookies
        Section 16.3. Reading Cookies
        Section 16.4. Cookie Example
        Chapter 17. The Document Object Model
        Section 17.1. An Overview of the DOM
        Section 17.2. Using the Core DOM API
        Section 17.3. DOM Compatibility with Internet Explorer 4
        Section 17.4. DOM Compatibility with Netscape 4
        Section 17.5. Convenience Methods: The Traversal and Range APIs
        Chapter 18. Cascading Style Sheets and Dynamic HTML
        Section 18.1. Styles and Style Sheets with CSS
        Section 18.2. Element Positioning with CSS
        Section 18.3. Scripting Styles
        Section 18.4. DHTML in Fourth-Generation Browsers
        Section 18.5. Other DOM APIs for Styles and Style Sheets
        Chapter 19. Events and Event Handling
        Section 19.1. Basic Event Handling
        Section 19.2. Advanced Event Handling with DOM Level 2
        Section 19.3. The Internet Explorer Event Model
        Section 19.4. The Netscape 4 Event Model
        Chapter 20. Compatibility Techniques
        Section 20.1. Platform and Browser Compatibility
        Section 20.2. Language Version Compatibility
        Section 20.3. Compatibility with Non-JavaScript Browsers
        Chapter 21. JavaScript Security
        Section 21.1. JavaScript and Security
        Section 21.2. Restricted Features
        Section 21.3. The Same-Origin Policy
        Section 21.4. Security Zones and Signed Scripts
        Chapter 22. Using Java with JavaScript
        Section 22.1. Scripting Java Applets
        Section 22.2. Using JavaScript from Java
        Section 22.3. Using Java Classes Directly
        Section 22.4. LiveConnect Data Types
        Section 22.5. LiveConnect Data Conversion
        Section 22.6. JavaScript Conversion of JavaObjects
        Section 22.7. Java-to-JavaScript Data Conversion
      - Part III: Core JavaScript Reference
        Chapter 23. Core JavaScript Reference
        Sample Entry
        arguments[ ]
        Arguments
        Arguments.callee
        Arguments.length
        Array
        Array.concat( )
        Array.join( )
        Array.length
        Array.pop( )
        Array.push( )
        Array.reverse( )
        Array.shift( )
        Array.slice( )
        Array.sort( )
        Array.splice( )
        Array.toLocaleString( )
        Array.toString( )
        Array.unshift( )
        Boolean
        Boolean.toString( )
        Boolean.valueOf( )
        Date
        Date.getDate( )
        Date.getDay( )
        Date.getFullYear( )
        Date.getHours( )
        Date.getMilliseconds( )
        Date.getMinutes( )
        Date.getMonth( )
        Date.getSeconds( )
        Date.getTime( )
        Date.getTimezoneOffset( )
        Date.getUTCDate( )
        Date.getUTCDay( )
        Date.getUTCFullYear( )
        Date.getUTCHours( )
        Date.getUTCMilliseconds( )
        Date.getUTCMinutes( )
        Date.getUTCMonth( )
        Date.getUTCSeconds( )
        Date.getYear( )
        Date.parse( )
        Date.setDate( )
        Date.setFullYear( )
        Date.setHours( )
        Date.setMilliseconds( )
        Date.setMinutes( )
        Date.setMonth( )
        Date.setSeconds( )
        Date.setTime( )
        Date.setUTCDate( )
        Date.setUTCFullYear( )
        Date.setUTCHours( )
        Date.setUTCMilliseconds( )
        Date.setUTCMinutes( )
        Date.setUTCMonth( )
        Date.setUTCSeconds( )
        Date.setYear( )
        Date.toDateString( )
        Date.toGMTString( )
        Date.toLocaleDateString( )
        Date.toLocaleString( )
        Date.toLocaleTimeString( )
        Date.toString( )
        Date.toTimeString( )
        Date.toUTCString( )
        Date.UTC( )
        Date.valueOf( )
        decodeURI( )
        decodeURIComponent( )
        encodeURI( )
        encodeURIComponent( )
        Error
        Error.message
        Error.name
        Error.toString( )
        escape( )
        eval( )
        EvalError
        Function
        Function.apply( )
        Function.arguments[]
        Function.call( )
        Function.caller
        Function.length
        Function.prototype
        Function.toString( )
        Global
        Infinity
        isFinite( )
        isNaN( )
        Math
        Math.abs( )
        Math.acos( )
        Math.asin( )
        Math.atan( )
        Math.atan2( )
        Math.ceil( )
        Math.cos( )
        Math.E
        Math.exp( )
        Math.floor( )
        Math.LN10
        Math.LN2
        Math.log( )
        Math.LOG10E
        Math.LOG2E
        Math.max( )
        Math.min( )
        Math.PI
        Math.pow( )
        Math.random( )
        Math.round( )
        Math.sin( )
        Math.sqrt( )
        Math.SQRT1_2
        Math.SQRT2
        Math.tan( )
        NaN
        Number
        Number.MAX_VALUE
        Number.MIN_VALUE
        Number.NaN
        Number.NEGATIVE_INFINITY
        Number.POSITIVE_INFINITY
        Number.toExponential( )
        Number.toFixed( )
        Number.toLocaleString( )
        Number.toPrecision( )
        Number.toString( )
        Number.valueOf( )
        Object
        Object.constructor
        Object.hasOwnProperty( )
        Object.isPrototypeOf( )
        Object.propertyIsEnumerable( )
        Object.toLocaleString( )
        Object.toString( )
        Object.valueOf( )
        parseFloat( )
        parseInt( )
        RangeError
        ReferenceError
        RegExp
        RegExp.exec( )
        RegExp.global
        RegExp.ignoreCase
        RegExp.lastIndex
        RegExp.source
        RegExp.test( )
        RegExp.toString( )
        String
        String.charAt( )
        String.charCodeAt( )
        String.concat( )
        String.fromCharCode( )
        String.indexOf( )
        String.lastIndexOf( )
        String.length
        String.localeCompare( )
        String.match( )
        String.replace( )
        String.search( )
        String.slice( )
        String.split( )
        String.substr( )
        String.substring( )
        String.toLocaleLowerCase( )
        String.toLocaleUpperCase( )
        String.toLowerCase( )
        String.toString( )
        String.toUpperCase( )
        String.valueOf( )
        SyntaxError
        TypeError
        undefined
        unescape( )
        URIError
      - Part IV: Client-Side JavaScript Reference
        Chapter 24. Client-Side JavaScript Reference
        Sample Entry
        Anchor
        Applet
        Area
        Button
        Button.onclick
        Checkbox
        Checkbox.onclick
        Document
        Document.all[]
        Document.captureEvents( )
        Document.clear( )
        Document.close( )
        Document.cookie
        Document.domain
        Document.elementFromPoint( )
        Document.getSelection( )
        Document.handleEvent( )
        Document.lastModified
        Document.links[]
        Document.open( )
        Document.releaseEvents( )
        Document.routeEvent( )
        Document.URL
        Document.write( )
        Document.writeln( )
        Element
        Event
        FileUpload
        FileUpload.onchange
        Form
        Form.elements[]
        Form.onreset
        Form.onsubmit
        Form.reset( )
        Form.submit( )
        Form.target
        Frame
        getClass( )
        Hidden
        History
        History.back( )
        History.forward( )
        History.go( )
        HTMLElement
        HTMLElement.contains( )
        HTMLElement.getAttribute( )
        HTMLElement.handleEvent( )
        HTMLElement.insertAdjacentHTML( )
        HTMLElement.insertAdjacentText( )
        HTMLElement.onclick
        HTMLElement.ondblclick
        HTMLElement.onhelp
        HTMLElement.onkeydown
        HTMLElement.onkeypress
        HTMLElement.onkeyup
        HTMLElement.onmousedown
        HTMLElement.onmousemove
        HTMLElement.onmouseout
        HTMLElement.onmouseover
        HTMLElement.onmouseup
        HTMLElement.removeAttribute( )
        HTMLElement.scrollIntoView( )
        HTMLElement.setAttribute( )
        Image
        Image.onabort
        Image.onerror
        Image.onload
        Input
        Input.blur( )
        Input.click( )
        Input.focus( )
        Input.name
        Input.onblur
        Input.onchange
        Input.onclick
        Input.onfocus
        Input.select( )
        Input.type
        Input.value
        JavaArray
        JavaClass
        JavaObject
        JavaPackage
        JSObject
        JSObject.call( )
        JSObject.eval( )
        JSObject.getMember( )
        JSObject.getSlot( )
        JSObject.getWindow( )
        JSObject.removeMember( )
        JSObject.setMember( )
        JSObject.setSlot( )
        JSObject.toString( )
        Layer
        Layer.captureEvents( )
        Layer.handleEvent( )
        Layer.load( )
        Layer.moveAbove( )
        Layer.moveBelow( )
        Layer.moveBy( )
        Layer.moveTo( )
        Layer.moveToAbsolute( )
        Layer.offset( )
        Layer.releaseEvents( )
        Layer.resizeBy( )
        Layer.resizeTo( )
        Layer.routeEvent( )
        Link
        Link.onclick
        Link.onmouseout
        Link.onmouseover
        Link.target
        Location
        Location.reload( )
        Location.replace( )
        MimeType
        Navigator
        Navigator.javaEnabled( )
        Navigator.plugins.refresh( )
        Option
        Password
        Plugin
        Radio
        Radio.onclick
        Reset
        Reset.onclick
        Screen
        Select
        Select.onchange
        Select.options[]
        Style
        Submit
        Submit.onclick
        Text
        Text.onchange
        Textarea
        Textarea.onchange
        URL
        Window
        Window.alert( )
        Window.back( )
        Window.blur( )
        Window.captureEvents( )
        Window.clearInterval( )
        Window.clearTimeout( )
        Window.close( )
        Window.confirm( )
        Window.defaultStatus
        Window.focus( )
        Window.forward( )
        Window.handleEvent( )
        Window.home( )
        Window.moveBy( )
        Window.moveTo( )
        Window.name
        Window.navigate( )
        Window.onblur
        Window.onerror
        Window.onfocus
        Window.onload
        Window.onmove
        Window.onresize
        Window.onunload
        Window.open( )
        Window.print( )
        Window.prompt( )
        Window.releaseEvents( )
        Window.resizeBy( )
        Window.resizeTo( )
        Window.routeEvent( )
        Window.scroll( )
        Window.scrollBy( )
        Window.scrollTo( )
        Window.setInterval( )
        Window.setTimeout( )
        Window.status
        Window.stop( )
      - Part V: W3C DOM Reference
        Chapter 25. W3C DOM Reference
        Sample Entry
        AbstractView
        AbstractView.getComputedStyle( )
        Attr
        CDATASection
        CharacterData
        CharacterData.appendData( )
        CharacterData.deleteData( )
        CharacterData.insertData( )
        CharacterData.replaceData( )
        CharacterData.substringData( )
        Comment
        Counter
        CSS2Properties
        CSSCharsetRule
        CSSFontFaceRule
        CSSImportRule
        CSSMediaRule
        CSSMediaRule.deleteRule( )
        CSSMediaRule.insertRule( )
        CSSPageRule
        CSSPrimitiveValue
        CSSPrimitiveValue.getCounterValue( )
        CSSPrimitiveValue.getFloatValue( )
        CSSPrimitiveValue.getRectValue( )
        CSSPrimitiveValue.getRGBColorValue( )
        CSSPrimitiveValue.getStringValue( )
        CSSPrimitiveValue.setFloatValue( )
        CSSPrimitiveValue.setStringValue( )
        CSSRule
        CSSRuleList
        CSSRuleList.item( )
        CSSStyleDeclaration
        CSSStyleDeclaration.getPropertyCSSValue( )
        CSSStyleDeclaration.getPropertyPriority( )
        CSSStyleDeclaration.getPropertyValue( )
        CSSStyleDeclaration.item( )
        CSSStyleDeclaration.removeProperty( )
        CSSStyleDeclaration.setProperty( )
        CSSStyleRule
        CSSStyleSheet
        CSSStyleSheet.deleteRule( )
        CSSStyleSheet.insertRule( )
        CSSUnknownRule
        CSSValue
        CSSValueList
        CSSValueList.item( )
        Document
        Document.createAttribute( )
        Document.createAttributeNS( )
        Document.createCDATASection( )
        Document.createComment( )
        Document.createDocumentFragment( )
        Document.createElement( )
        Document.createElementNS( )
        Document.createEntityReference( )
        Document.createEvent( )
        Document.createNodeIterator( )
        Document.createProcessingInstruction( )
        Document.createRange( )
        Document.createTextNode( )
        Document.createTreeWalker( )
        Document.getElementById( )
        Document.getElementsByTagName( )
        Document.getElementsByTagNameNS( )
        Document.getOverrideStyle( )
        Document.importNode( )
        DocumentCSS
        DocumentEvent
        DocumentFragment
        DocumentRange
        DocumentStyle
        DocumentTraversal
        DocumentType
        DocumentView
        DOMException
        DOMImplementation
        DOMImplementation.createCSSStyleSheet( )
        DOMImplementation.createDocument( )
        DOMImplementation.createDocumentType( )
        DOMImplementation.createHTMLDocument( )
        DOMImplementation.hasFeature( )
        DOMImplementationCSS
        Element
        Element.getAttribute( )
        Element.getAttributeNode( )
        Element.getAttributeNodeNS( )
        Element.getAttributeNS( )
        Element.getElementsByTagName( )
        Element.getElementsByTagNameNS( )
        Element.hasAttribute( )
        Element.hasAttributeNS( )
        Element.removeAttribute( )
        Element.removeAttributeNode( )
        Element.removeAttributeNS( )
        Element.setAttribute( )
        Element.setAttributeNode( )
        Element.setAttributeNodeNS( )
        Element.setAttributeNS( )
        ElementCSSInlineStyle
        Entity
        EntityReference
        Event
        Event.initEvent( )
        Event.preventDefault( )
        Event.stopPropagation( )
        EventException
        EventListener
        EventTarget
        EventTarget.addEventListener( )
        EventTarget.dispatchEvent( )
        EventTarget.removeEventListener( )
        HTMLAnchorElement
        HTMLAnchorElement.blur( )
        HTMLAnchorElement.focus( )
        HTMLBodyElement
        HTMLCollection
        HTMLCollection.item( )
        HTMLCollection.namedItem( )
        HTMLDocument
        HTMLDocument.close( )
        HTMLDocument.getElementById( )
        HTMLDocument.getElementsByName( )
        HTMLDocument.open( )
        HTMLDocument.write( )
        HTMLDocument.writeln( )
        HTMLDOMImplementation
        HTMLElement
        HTMLFormElement
        HTMLFormElement.reset( )
        HTMLFormElement.submit( )
        HTMLInputElement
        HTMLInputElement.blur( )
        HTMLInputElement.click( )
        HTMLInputElement.focus( )
        HTMLInputElement.select( )
        HTMLOptionElement
        HTMLSelectElement
        HTMLSelectElement.add( )
        HTMLSelectElement.blur( )
        HTMLSelectElement.focus( )
        HTMLSelectElement.remove( )
        HTMLTableCaptionElement
        HTMLTableCellElement
        HTMLTableColElement
        HTMLTableElement
        HTMLTableElement.createCaption( )
        HTMLTableElement.createTFoot( )
        HTMLTableElement.createTHead( )
        HTMLTableElement.deleteCaption( )
        HTMLTableElement.deleteRow( )
        HTMLTableElement.deleteTFoot( )
        HTMLTableElement.deleteTHead( )
        HTMLTableElement.insertRow( )
        HTMLTableRowElement
        HTMLTableRowElement.deleteCell( )
        HTMLTableRowElement.insertCell( )
        HTMLTableSectionElement
        HTMLTableSectionElement.deleteRow( )
        HTMLTableSectionElement.insertRow( )
        HTMLTextAreaElement
        HTMLTextAreaElement.blur( )
        HTMLTextAreaElement.focus( )
        HTMLTextAreaElement.select( )
        LinkStyle
        MediaList
        MediaList.appendMedium( )
        MediaList.deleteMedium( )
        MediaList.item( )
        MouseEvent
        MouseEvent.initMouseEvent( )
        MutationEvent
        MutationEvent.initMutationEvent( )
        NamedNodeMap
        NamedNodeMap.getNamedItem( )
        NamedNodeMap.getNamedItemNS( )
        NamedNodeMap.item( )
        NamedNodeMap.removeNamedItem( )
        NamedNodeMap.removeNamedItemNS( )
        NamedNodeMap.setNamedItem( )
        NamedNodeMap.setNamedItemNS( )
        Node
        Node.appendChild( )
        Node.cloneNode( )
        Node.hasAttributes( )
        Node.hasChildNodes( )
        Node.insertBefore( )
        Node.isSupported( )
        Node.normalize( )
        Node.removeChild( )
        Node.replaceChild( )
        NodeFilter
        NodeIterator
        NodeIterator.detach( )
        NodeIterator.nextNode( )
        NodeIterator.previousNode( )
        NodeList
        NodeList.item( )
        Notation
        ProcessingInstruction
        Range
        Range.cloneContents( )
        Range.cloneRange( )
        Range.collapse( )
        Range.compareBoundaryPoints( )
        Range.deleteContents( )
        Range.detach( )
        Range.extractContents( )
        Range.insertNode( )
        Range.selectNode( )
        Range.selectNodeContents( )
        Range.setEnd( )
        Range.setEndAfter( )
        Range.setEndBefore( )
        Range.setStart( )
        Range.setStartAfter( )
        Range.setStartBefore( )
        Range.surroundContents( )
        Range.toString( )
        RangeException
        Rect
        RGBColor
        StyleSheet
        StyleSheetList
        StyleSheetList.item( )
        Text
        Text.splitText( )
        TreeWalker
        TreeWalker.firstChild( )
        TreeWalker.lastChild( )
        TreeWalker.nextNode( )
        TreeWalker.nextSibling( )
        TreeWalker.parentNode( )
        TreeWalker.previousNode( )
        TreeWalker.previousSibling( )
        UIEvent
        UIEvent.initUIEvent( )
        ViewCSS
      - Part VI: Class, Property, Method, and Event Handler Index
        Chapter 26. Class, Property, Method, and Event Handler Index
        Section 26.1. A
        Section 26.2. B
        Section 26.3. C
        Section 26.4. D
        Section 26.5. E
        Section 26.6. F
        Section 26.7. G
        Section 26.8. H
        Section 26.9. I
        Section 26.10. J
        Section 26.11. K
        Section 26.12. L
        Section 26.13. M
        Section 26.14. N
        Section 26.15. O
        Section 26.16. P
        Section 26.17. Q
        Section 26.18. R
        Section 26.19. S
        Section 26.20. T
        Section 26.21. U
        Section 26.22. V
        Section 26.23. W
        Section 26.24. X
        Section 26.25. Y
        Section 26.26. Z
    - JavaScript & DHTML Cookbook
      - Chapter 1. Strings
        Section 1.0. Introduction
        Section 1.1. Concatenating (Joining) Strings
        Section 1.2. Accessing Substrings
        Section 1.3. Changing String Case
        Section 1.4. Testing Equality of Two Strings
        Section 1.5. Testing String Containment Without Regular Expressions
        Section 1.6. Testing String Containment with Regular Expressions
        Section 1.7. Searching and Replacing Substrings
        Section 1.8. Using Special and Escaped Characters
        Section 1.9. Reading and Writing Strings for Cookies
        Section 1.10. Converting Between Unicode Values and String Characters
        Section 1.11. Encoding and Decoding URL Strings
        Section 1.12. Encoding and Decoding Base64 Strings
      - Chapter 2. Numbers and Dates
        Section 2.0. Introduction
        Section 2.1. Converting Between Numbers and Strings
        Section 2.2. Testing a Number's Validity
        Section 2.3. Testing Numeric Equality
        Section 2.4. Rounding Floating-Point Numbers
        Section 2.5. Formatting Numbers for Text Display
        Section 2.6. Converting Between Decimal and Hexadecimal Numbers
        Section 2.7. Generating Pseudorandom Numbers
        Section 2.8. Calculating Trigonometric Functions
        Section 2.9. Creating a Date Object
        Section 2.10. Calculating a Previous or Future Date
        Section 2.11. Calculating the Number of Days Between Two Dates
        Section 2.12. Validating a Date
      - Chapter 3. Arrays and Objects
        Section 3.0. Introduction
        Section 3.1. Creating a Simple Array
        Section 3.2. Creating a Multidimensional Array
        Section 3.3. Converting Between Arrays and Strings
        Section 3.4. Doing Something with the Items in an Array
        Section 3.5. Sorting a Simple Array
        Section 3.6. Combining Arrays
        Section 3.7. Dividing Arrays
        Section 3.8. Creating a Custom Object
        Section 3.9. Simulating a Hash Table for Fast Array Lookup
        Section 3.10. Doing Something with a Property of an Object
        Section 3.11. Sorting an Array of Objects
        Section 3.12. Customizing an Object's Prototype
        Section 3.13. Converting Arrays and Custom Objects to Strings
      - Chapter 4. Variables, Functions, and Flow Control
        Section 4.0. Introduction
        Section 4.1. Creating a JavaScript Variable
        Section 4.2. Creating a Named Function
        Section 4.3. Nesting Named Functions
        Section 4.4. Creating an Anonymous Function
        Section 4.5. Delaying a Function Call
        Section 4.6. Branching Execution Based on Conditions
        Section 4.7. Handling Script Errors Gracefully
        Section 4.8. Improving Script Performance
      - Chapter 5. Browser Feature Detection
        Section 5.0. Introduction
        Section 5.1. Detecting the Browser Brand
        Section 5.2. Detecting an Early Browser Version
        Section 5.3. Detecting the Internet Explorer Version
        Section 5.4. Detecting the Netscape Navigator Version
        Section 5.5. Detecting the Client Operating System
        Section 5.6. Detecting Object Support
        Section 5.7. Detecting Object Property and Method Support
        Section 5.8. Detecting the Browser Written Language
        Section 5.9. Detecting Cookie Availability
        Section 5.10. Defining Browser- or Feature-Specific Links
        Section 5.11. Testing on Multiple Browser Versions
      - Chapter 6. Managing Browser Windows
        Section 6.0. Introduction
        Section 6.1. Setting the Main Window's Size
        Section 6.2. Positioning the Main Window
        Section 6.3. Maximizing the Main Window
        Section 6.4. Creating a New Window
        Section 6.5. Bringing a Window to the Front
        Section 6.6. Communicating with a New Window
        Section 6.7. Communicating Back to the Main Window
        Section 6.8. Using Internet Explorer Modal/Modeless Windows
        Section 6.9. Simulating a Cross-Browser Modal Dialog Window
        Section 6.10. Simulating a Window with Layers
      - Chapter 7. Managing Multiple Frames
        Section 7.0. Introduction
        Section 7.1. Creating a Blank Frame in a New Frameset
        Section 7.2. Changing the Content of One Frame from Another
        Section 7.3. Changing the Content of Multiple Frames at Once
        Section 7.4. Replacing a Frameset with a Single Page
        Section 7.5. Avoiding Being "Framed" by Another Site
        Section 7.6. Assuring a Page Loads in its Frameset
        Section 7.7. Reading a Frame's Dimensions
        Section 7.8. Resizing Frames
        Section 7.9. Setting Frameset Specifications Dynamically
      - Chapter 8. Dynamic Forms
        Section 8.0. Introduction
        Section 8.1. Auto-Focusing the First Text Field
        Section 8.2. Performing Common Text Field Validations
        Section 8.3. Preventing Form Submission upon Validation Failure
        Section 8.4. Auto-Focusing an Invalid Text Field Entry
        Section 8.5. Changing a Form's Action
        Section 8.6. Blocking Submissions from the Enter Key
        Section 8.7. Advancing Text Field Focus with the Enter Key
        Section 8.8. Submitting a Form by an Enter Key Press in Any Text Box
        Section 8.9. Disabling Form Controls
        Section 8.10. Hiding and Showing Form Controls
        Section 8.11. Allowing Only Numbers (or Letters) in a Text Box
        Section 8.12. Auto-Tabbing for Fixed-Length Text Boxes
        Section 8.13. Changing select Element Content
        Section 8.14. Copying Form Data Between Pages
      - Chapter 9. Managing Events
        Section 9.0. Introduction
        Section 9.1. Equalizing the IE and W3C Event Models
        Section 9.2. Initiating a Process After the Page Loads
        Section 9.3. Determining the Coordinates of a Click Event
        Section 9.4. Preventing an Event from Performing Its Default Behavior
        Section 9.5. Blocking Double Clicks
        Section 9.6. Determining Which Element Received an Event
        Section 9.7. Determining Which Mouse Button Was Pressed
        Section 9.8. Reading Which Character Key Was Typed
        Section 9.9. Reading Which Noncharacter Key Was Pressed
        Section 9.10. Determining Which Modifier Keys Were Pressed During an Event
        Section 9.11. Determining the Element the Cursor Rolled From/To
        Section 9.12. Synchronizing Sounds to Events
      - Chapter 10. Page Navigation Techniques
        Section 10.0. Introduction
        Section 10.1. Loading a New Page or Anchor
        Section 10.2. Keeping a Page Out of the Browser History
        Section 10.3. Using a select Element for Navigation
        Section 10.4. Passing Data Between Pages Via Cookies
        Section 10.5. Passing Data Between Pages Via Frames
        Section 10.6. Passing Data Between Pages Via URLs
        Section 10.7. Creating a Contextual (Right-Click) Menu
        Section 10.8. Creating Drop-Down Navigation Menus
        Section 10.9. Providing Navigation Trail Menus
        Section 10.10. Creating Expandable Menus
        Section 10.11. Creating Collapsible XML Menus
      - Chapter 11. Managing Style Sheets
        Section 11.0. Introduction
        Section 11.1. Assigning Style Sheet Rules to an Element Globally
        Section 11.2. Assigning Style Sheet Rules to a Subgroup of Elements
        Section 11.3. Assigning Style Sheet Rules to an Individual Element
        Section 11.4. Importing External Style Sheets
        Section 11.5. Importing Browser- or Operating System-Specific Style Sheets
        Section 11.6. Changing Imported Style Sheets After Loading
        Section 11.7. Enabling/Disabling Style Sheets
        Section 11.8. Toggling Between Style Sheets for an Element
        Section 11.9. Overriding a Style Sheet Rule
        Section 11.10. Turning Arbitrary Content into a Styled Element
        Section 11.11. Creating Center-Aligned Body Elements
        Section 11.12. Reading Effective Style Sheet Property Values
        Section 11.13. Forcing Version 6 Browsers into Standards-Compatibility Mode
      - Chapter 12. Visual Effects for Stationary Content
        Section 12.0. Introduction
        Section 12.1. Precaching Images
        Section 12.2. Swapping Images (Rollovers)
        Section 12.3. Changing Text Style Properties
        Section 12.4. Offering Body Text Size Choices to Users
        Section 12.5. Creating Custom Link Styles
        Section 12.6. Changing Page Background Colors and Images
        Section 12.7. Hiding and Showing Elements
        Section 12.8. Adjusting Element Transparency
        Section 12.9. Creating Transition Visual Effects
      - Chapter 13. Positioning HTML Elements
        Section 13.0. Introduction
        Section 13.1. Making an Element Positionable in the Document Space
        Section 13.2. Connecting a Positioned Element to a Body Element
        Section 13.3. Controlling Positioning Via a DHTML JavaScript Library
        Section 13.4. Deciding Between div and span Containers
        Section 13.5. Adjusting Positioned Element Stacking Order (z-order)
        Section 13.6. Centering an Element on Top of Another Element
        Section 13.7. Centering an Element in a Window or Frame
        Section 13.8. Determining the Locat