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 Location of a Nonpositioned Element
        Section 13.9. Animating Straight-Line Element Paths
        Section 13.10. Animating Circular Element Paths
        Section 13.11. Creating a Draggable Element
        Section 13.12. Scrolling div Content
        Section 13.13. Creating a Custom Scrollbar
      - Chapter 14. Creating Dynamic Content
        Section 14.0. Introduction
        Section 14.1. Writing Dynamic Content During Page Loading
        Section 14.2. Creating New Page Content Dynamically
        Section 14.3. Including External HTML Content
        Section 14.4. Embedding XML Data
        Section 14.5. Embedding Data as JavaScript Objects
        Section 14.6. Transforming XML Data into HTML Tables
        Section 14.7. Transforming JavaScript Objects into HTML Tables
        Section 14.8. Converting an XML Node Tree to JavaScript Objects
        Section 14.9. Creating a New Element
        Section 14.10. Creating Text Content for a New Element
        Section 14.11. Creating Mixed Element and Text Nodes
        Section 14.12. Inserting and Populating an iframe Element
        Section 14.13. Getting a Reference to an HTML Element Object
        Section 14.14. Replacing Portions of Body Content
        Section 14.15. Removing Body Content
        Section 14.16. Sorting Dynamic Tables
        Section 14.17. Walking the Document Node Tree
        Section 14.18. Capturing Document Content
      - Chapter 15. Dynamic Content Applications
        Section 15.0. Introduction
        Section 15.1. Displaying a Random Aphorism
        Section 15.2. Converting a User Selection into an Arbitrary Element
        Section 15.3. Automating the Search-and-Replace of Body Content
        Section 15.4. Creating a Slide Show
        Section 15.5. Auto-Scrolling the Page
        Section 15.6. Greeting Users with Their Time of Day
        Section 15.7. Displaying the Number of Days Before Christmas
        Section 15.8. Displaying a Countdown Timer
        Section 15.9. Creating a Calendar Date Picker
        Section 15.10. Displaying an Animated Progress Bar
      - Appendix A. Keyboard Event Character Values
      - Appendix B. Keyboard Key Code Values
      - Appendix C. ECMAScript Reserved Keywords
  - AJAX
  - Other
    - C++ Primer, Fourth Edition
      - Preface
        Changes to the Fourth Edition
        Structure of This Book
        Acknowledgments
        Chapter 1. Getting Started
        Section 1.1. Writing a Simple C++ Program
        Section 1.2. A First Look at Input/Output
        Section 1.3. A Word About Comments
        Section 1.4. Control Structures
        Section 1.5. Introducing Classes
        Section 1.6. The C++ Program
        Chapter Summary
        Defined Terms
      - Part I: The Basics
        Chapter 2. Variables and Basic Types
        Section 2.1. Primitive Built-in Types
        Section 2.2. Literal Constants
        Section 2.3. Variables
        Section 2.4. const Qualifier
        Section 2.5. References
        Section 2.6. Typedef Names
        Section 2.7. Enumerations
        Section 2.8. Class Types
        Section 2.9. Writing Our Own Header Files
        Chapter Summary
        Defined Terms
        Chapter 3. Library Types
        Section 3.1. Namespace using Declarations
        Section 3.2. Library string Type
        Section 3.3. Library vector Type
        Section 3.4. Introducing Iterators
        Section 3.5. Library bitset Type
        Chapter Summary
        Defined Terms
        Chapter 4. Arrays and Pointers
        Section 4.1. Arrays
        Section 4.2. Introducing Pointers
        Section 4.3. C-Style Character Strings
        Section 4.4. Multidimensioned Arrays
        Chapter Summary
        Defined Terms
        Chapter 5. Expressions
        Section 5.1. Arithmetic Operators
        Section 5.2. Relational and Logical Operators
        Section 5.3. The Bitwise Operators
        Section 5.4. Assignment Operators
        Section 5.5. Increment and Decrement Operators
        Section 5.6. The Arrow Operator
        Section 5.7. The Conditional Operator
        Section 5.8. The sizeof Operator
        Section 5.9. Comma Operator
        Section 5.10. Evaluating Compound Expressions
        Section 5.11. The new and delete Expressions
        Section 5.12. Type Conversions
        Chapter Summary
        Defined Terms
        Chapter 6. Statements
        Section 6.1. Simple Statements
        Section 6.2. Declaration Statements
        Section 6.3. Compound Statements (Blocks)
        Section 6.4. Statement Scope
        Section 6.5. The if Statement
        Section 6.6. The switch Statement
        Section 6.7. The while Statement
        Section 6.8. The for Loop Statement
        Section 6.9. The do while Statement
        Section 6.10. The break Statement
        Section 6.11. The continue Statement
        Section 6.12. The goto Statement
        Section 6.13. try Blocks and Exception Handling
        Section 6.14. Using the Preprocessor for Debugging
        Chapter Summary
        Defined Terms
        Chapter 7. Functions
        Section 7.1. Defining a Function
        Section 7.2. Argument Passing
        Section 7.3. The return Statement
        Section 7.4. Function Declarations
        Section 7.5. Local Objects
        Section 7.6. Inline Functions
        Section 7.7. Class Member Functions
        Section 7.8. Overloaded Functions
        Section 7.9. Pointers to Functions
        Chapter Summary
        Defined Terms
        Chapter 8. The IO Library
        Section 8.1. An Object-Oriented Library
        Section 8.2. Condition States
        Section 8.3. Managing the Output Buffer
        Section 8.4. File Input and Output
        Section 8.5. String Streams
        Chapter Summary
        Defined Terms
      - Part II: Containers and Algorithms
        Chapter 9. Sequential Containers
        Section 9.1. Defining a Sequential Container
        Section 9.2. Iterators and Iterator Ranges
        Section 9.3. Sequence Container Operations
        Section 9.4. How a vector Grows
        Section 9.5. Deciding Which Container to Use
        Section 9.6. strings Revisited
        Section 9.7. Container Adaptors
        Chapter Summary
        Defined Terms
        Chapter 10. Associative Containers
        Section 10.1. Preliminaries: the pair Type
        Section 10.2. Associative Containers
        Section 10.3. The map Type
        Section 10.4. The set Type
        Section 10.5. The multimap and multiset Types
        Section 10.6. Using Containers: Text-Query Program
        Chapter Summary
        Defined Terms
        Chapter 11. Generic Algorithms
        Section 11.1. Overview
        Section 11.2. A First Look at the Algorithms
        Section 11.3. Revisiting Iterators
        Section 11.4. Structure of Generic Algorithms
        Section 11.5. Container-Specific Algorithms
        Chapter Summary
        Defined Terms
      - Part III: Classes and Data Abstraction
        Chapter 12. Classes
        Section 12.1. Class Definitions and Declarations
        Section 12.2. The Implicit this Pointer
        Section 12.3. Class Scope
        Section 12.4. Constructors
        Section 12.5. Friends
        Section 12.6. static Class Members
        Chapter Summary
        Defined Terms
        Chapter 13. Copy Control
        Section 13.1. The Copy Constructor
        Section 13.2. The Assignment Operator
        Section 13.3. The Destructor
        Section 13.4. A Message-Handling Example
        Section 13.5. Managing Pointer Members
        Chapter Summary
        Defined Terms
        Chapter 14. Overloaded Operations and Conversions
        Section 14.1. Defining an Overloaded Operator
        Section 14.2. Input and Output Operators
        Section 14.3. Arithmetic and Relational Operators
        Section 14.4. Assignment Operators
        Section 14.5. Subscript Operator
        Section 14.6. Member Access Operators
        Section 14.7. Increment and Decrement Operators
        Section 14.8. Call Operator and Function Objects
        Section 14.9. Conversions and Class Types
        Chapter Summary
        Defined Terms
      - Part IV: Object-Oriented and Generic Programming
        Chapter 15. Object-Oriented Programming
        Section 15.1. OOP: An Overview
        Section 15.2. Defining Base and Derived Classes
        Section 15.3. Conversions and Inheritance
        Section 15.4. Constructors and Copy Control
        Section 15.5. Class Scope under Inheritance
        Section 15.6. Pure Virtual Functions
        Section 15.7. Containers and Inheritance
        Section 15.8. Handle Classes and Inheritance
        Section 15.9. Text Queries Revisited
        Chapter Summary
        Defined Terms
        Chapter 16. Templates and Generic Programming
        Section 16.1. Template Definitions
        Section 16.2. Instantiation
        Section 16.3. Template Compilation Models
        Section 16.4. Class Template Members
        Section 16.5. A Generic Handle Class
        Section 16.6. Template Specializations
        Section 16.7. Overloading and Function Templates
        Chapter Summary
        Defined Terms
      - Part V: Advanced Topics
        Chapter 17. Tools for Large Programs
        Section 17.1. Exception Handling
        Section 17.2. Namespaces
        Section 17.3. Multiple and Virtual Inheritance
        Chapter Summary
        Defined Terms
        Chapter 18. Specialized Tools and Techniques
        Section 18.1. Optimizing Memory Allocation
        Section 18.2. Run-Time Type Identification
        Section 18.3. Pointer to Class Member
        Section 18.4. Nested Classes
        Section 18.5. Union: A Space-Saving Class
        Section 18.6. Local Classes
        Section 18.7. Inherently Nonportable Features
        Chapter Summary
        Defined Terms
        Appendix A. The Library
        Section A.1. Library Names and Headers
        Section A.2. A Brief Tour of the Algorithms
        Section A.3. The IO Library Revisited
    - Learning Perl, 4th Edition
      - Chapter 1. Introduction
        Section 1.1. Questions and Answers
        Section 1.2. What Does "Perl" Stand For?
        Section 1.3. How Can I Get Perl?
        Section 1.4. How Do I Make a Perl Program?
        Section 1.5. A Whirlwind Tour of Perl
        Section 1.6. Exercises
      - Chapter 2. Scalar Data
        Section 2.1. Numbers
        Section 2.2. Strings
        Section 2.3. Perl's Built-in Warnings
        Section 2.4. Scalar Variables
        Section 2.5. Output with print
        Section 2.6. The if Control Structure
        Section 2.7. Getting User Input
        Section 2.8. The chomp Operator
        Section 2.9. The while Control Structure
        Section 2.10. The undef Value
        Section 2.11. The defined Function
        Section 2.12. Exercises
      - Chapter 3. Lists and Arrays
        Section 3.1. Accessing Elements of an Array
        Section 3.2. Special Array Indices
        Section 3.3. List Literals
        Section 3.4. List Assignment
        Section 3.5. Interpolating Arrays into Strings
        Section 3.6. The foreach Control Structure
        Section 3.7. Scalar and List Context
        Section 3.8. <STDIN> in List Context
        Section 3.9. Exercises
      - Chapter 4. Subroutines
        Section 4.1. Defining a Subroutine
        Section 4.2. Invoking a Subroutine
        Section 4.3. Return Values
        Section 4.4. Arguments
        Section 4.5. Private Variables in Subroutines
        Section 4.6. Variable-Length Parameter Lists
        Section 4.7. Notes on Lexical (my) Variables
        Section 4.8. The use strict Pragma
        Section 4.9. The return Operator
        Section 4.10. Non-Scalar Return Values
        Section 4.11. Exercises
      - Chapter 5. Input and Output
        Section 5.1. Input from Standard Input
        Section 5.2. Input from the Diamond Operator
        Section 5.3. The Invocation Arguments
        Section 5.4. Output to Standard Output
        Section 5.5. Formatted Output with printf
        Section 5.6. Filehandles
        Section 5.7. Opening a Filehandle
        Section 5.8. Fatal Errors with die
        Section 5.9. Using Filehandles
        Section 5.10. Reopening a Standard Filehandle
        Section 5.11. Exercises
      - Chapter 6. Hashes
        Section 6.1. What Is a Hash?
        Section 6.2. Hash Element Access
        Section 6.3. Hash Functions
        Section 6.4. Typical Use of a Hash
        Section 6.5. Exercises
      - Chapter 7. In the World of Regular Expressions
        Section 7.1. What Are Regular Expressions?
        Section 7.2. Using Simple Patterns
        Section 7.3. Character Classes
        Section 7.4. Exercises
      - Chapter 8. Matching with Regular Expressions
        Section 8.1. Matches with m//
        Section 8.2. Option Modifiers
        Section 8.3. Anchors
        Section 8.4. The Binding Operator, =~
        Section 8.5. Interpolating into Patterns
        Section 8.6. The Match Variables
        Section 8.7. General Quantifiers
        Section 8.8. Precedence
        Section 8.9. A Pattern Test Program
        Section 8.10. Exercises
      - Chapter 9. Processing Text with Regular Expressions
        Section 9.1. Substitutions with s///
        Section 9.2. The split Operator
        Section 9.3. The join Function
        Section 9.4. m// in List Context
        Section 9.5. More Powerful Regular Expressions
        Section 9.6. Exercises
      - Chapter 10. More Control Structures
        Section 10.1. The unless Control Structure
        Section 10.2. The until Control Structure
        Section 10.3. Expression Modifiers
        Section 10.4. The Naked Block Control Structure
        Section 10.5. The elsif Clause
        Section 10.6. Autoincrement and Autodecrement
        Section 10.7. The for Control Structure
        Section 10.8. Loop Controls
        Section 10.9. Logical Operators
        Section 10.10. Exercise
      - Chapter 11. File Tests
        Section 11.1. File Test Operators
        Section 11.2. The stat and lstat Functions
        Section 11.3. The localtime Function
        Section 11.4. Bitwise Operators
        Section 11.5. Using the Special Underscore Filehandle
        Section 11.6. Exercises
      - Chapter 12. Directory Operations
        Section 12.1. Moving Around the Directory Tree
        Section 12.2. Globbing
        Section 12.3. An Alternate Syntax for Globbing
        Section 12.4. Directory Handles
        Section 12.5. Recursive Directory Listing
        Section 12.6. Manipulating Files and Directories
        Section 12.7. Removing Files
        Section 12.8. Renaming Files
        Section 12.9. Links and Files
        Section 12.10. Making and Removing Directories
        Section 12.11. Modifying Permissions
        Section 12.12. Changing Ownership
        Section 12.13. Changing Timestamps
        Section 12.14. Exercises
      - Chapter 13. Strings and Sorting
        Section 13.1. Finding a Substring with index
        Section 13.2. Manipulating a Substring with substr
        Section 13.3. Formatting Data with sprintf
        Section 13.4. Advanced Sorting
        Section 13.5. Exercises
      - Chapter 14. Process Management
        Section 14.1. The system Function
        Section 14.2. The exec Function
        Section 14.3. The Environment Variables
        Section 14.4. Using Backquotes to Capture Output
        Section 14.5. Processes as Filehandles
        Section 14.6. Getting Down and Dirty with fork
        Section 14.7. Sending and Receiving Signals
        Section 14.8. Exercises
      - Chapter 15. Perl Modules
        Section 15.1. Finding Modules
        Section 15.2. Installing Modules
        Section 15.3. Using Simple Modules
        Section 15.4. Exercise
      - Chapter 16. Some Advanced Perl Techniques
        Section 16.1. Trapping Errors with eval
        Section 16.2. Picking Items from a List with grep
        Section 16.3. Transforming Items from a List with map
        Section 16.4. Unquoted Hash Keys
        Section 16.5. Slices
        Section 16.6. Exercise
      - Download this chapter Exercise Answers
        Section A.1. Answers to Chapter 2 Exercises
        Section A.2. Answers to Chapter 3 Exercises
        Section A.3. Answers to Chapter 4 Exercises
        Section A.4. Answers to Chapter 5 Exercises
        Section A.5. Answers to Chapter 6 Exercises
        Section A.6. Answers to Chapter 7 Exercises
        Section A.7. Answers to Chapter 8 Exercises
        Section A.8. Answers to Chapter 9 Exercises
        Section A.9. Answer to Chapter 10 Exercise
        Section A.10. Answers to Chapter 11 Exercises
        Section A.11. Answers to Chapter 12 Exercises
        Section A.12. Answers to Chapter 13 Exercises
        Section A.13. Answers to Chapter 14 Exercises
        Section A.14. Answer to Chapter 15 Exercise
        Section A.15. Answer to Chapter 16 Exercise
      - Download this chapter Beyond the Llama
        Section B.1. Further Documentation
        Section B.2. Regular Expressions
        Section B.3. Packages
        Section B.4. Extending Perl's Functionality
        Section B.5. Some Important Modules
        Section B.6. Pragmas
        Section B.7. Databases
        Section B.8. Other Operators and Functions
        Section B.9. Mathematics
        Section B.10. Lists and Arrays
        Section B.11. Bits and Pieces
        Section B.12. Formats
        Section B.13. Networking and IPC
        Section B.14. Security
        Section B.15. Debugging
        Section B.16. The Common Gateway Interface (CGI)
        Section B.17. Command-Line Options
        Section B.18. Built-in Variables
        Section B.19. Syntax Extensions
        Section B.20. References
        Section B.21. Tied Variables
        Section B.22. Operator Overloading
        Section B.23. Dynamic Loading
        Section B.24. Embedding
        Section B.25. Converting Other Languages to Perl
        Section B.26. Converting find Command Lines to Perl
        Section B.27. Command-Line Options in Your Programs
        Section B.28. Embedded Documentation
        Section B.29. More Ways to Open Filehandles
        Section B.30. Locales and Unicode
        Section B.31. Threads and Forking
        Section B.32. Graphical User Interfaces (GUIs)
        Section B.33. And More . . .
    - Mastering Regular Expressions, 2nd Edition
      - Chapter 1. Introduction to Regular Expressions
        Section 1.1. Solving Real Problems
        Section 1.2. Regular Expressions as a Language
        Section 1.3. The Regular-Expression Frame of Mind
        Section 1.4. Egrep Metacharacters
        Section 1.5. Expanding the Foundation
        Section 1.6. Personal Glimpses
        Section 1.7. Quiz Answer
      - Chapter 2. Extended Introductory Examples
        Section 2.1. About the Examples
        Section 2.2. Matching Text with Regular Expressions
        Section 2.3. Modifying Text with Regular Expressions
        Section 2.4. Quiz Answers
      - Chapter 3. Overview of Regular Expression Features and Flavors
        Section 3.1. A Casual Stroll Across the Regex Landscape
        Section 3.2. Care and Handling of Regular Expressions
        Section 3.3. Strings, Character Encodings, and Modes
        Section 3.4. Common Metacharacters and Features
        Section 3.5. Guide to the Advanced Chapters
      - Chapter 4. The Mechanics of Expression Processing
        Section 4.1. Start Your Engines!
        Section 4.2. Match Basics
        Section 4.3. Regex-Directed Versus Text-Directed
        Section 4.4. Backtracking
        Section 4.5. More About Greediness and Backtracking
        Section 4.6. NFA, DFA, and POSIX
        Section 4.7. Summary
        Section 4.8. Quiz Answers
      - Chapter 5. Practical Regex Techniques
        Section 5.1. Regex Balancing Act
        Section 5.2. A Few Short Examples
        Section 5.3. HTML-Related Examples
        Section 5.4. Extended Examples
      - Chapter 6. Crafting an Efficient Expression
        Section 6.1. A Sobering Example
        Section 6.2. A Global View of Backtracking
        Section 6.3. Benchmarking
        Section 6.4. Common Optimizations
        Section 6.5. Techniques for Faster Expressions
        Section 6.6. Unrolling the Loop
        Section 6.7. The Freeflowing Regex
        Section 6.8. In Summary: Think!
        Section 6.9. Quize Answers
      - Chapter 7. Perl
        Section 7.1. Regular Expressions as a Language Component
        Section 7.2. Perl's Regex Flavor
        Section 7.3. Regex-Related Perlisms
        Section 7.4. The qr/···/ Operator and Regex Objects
        Section 7.5. The Match Operator
        Section 7.6. The Substitution Operator
        Section 7.7. The Split Operator
        Section 7.8. Fun with Perl Enhancements
        Section 7.9. Perl Efficiency Issues
        Section 7.10. Final Comments
      - Chapter 8. Java
        Section 8.1. Judging a Regex Package
        Section 8.2. Object Models
        Section 8.3. Packages, Packages, Packages
        Section 8.4. Sun's Regex Package
        Section 8.5. A Quick Look at Jakarta-ORO
      - Chapter 9. .NET
        Section 9.1. .NET's Regex Flavor
        Section 9.2. Using .NET Regular Expressions
        Section 9.3. Core Object Details
        Section 9.4. Static "Convenience" Functions
        Section 9.5. Support Functions
        Section 9.6. Advanced .NET
    - Mastering Regular Expressions, 3rd Edition by Jeffrey E. F. Friedl Publisher: O'Reilly Pub Date: August 2006 Print ISBN-10: 0-596-52812-4 Print ISBN-13: 978-0-59-652812-6 Pages: 542
      - Chapter 1. Introduction to Regular Expressions
        Section 1.1. Solving Real Problems
        Section 1.2. Regular Expressions as a Language
        Section 1.3. The Regular-Expression Frame of Mind
        Section 1.4. Egrep Metacharacters
        Section 1.5. Expanding the Foundation
        Section 1.6. Personal Glimpses
      - Chapter 2. Extended Introductory Examples
        Section 2.1. About the Examples
        Section 2.2. Matching Text with Regular Expressions
        Section 2.3. Modifying Text with Regular Expressions
      - Chapter 3. Overview of Regular Expression Features and Flavors
        Section 3.1.
        Section 3.2. A Casual Stroll Across the Regex Landscape
        Section 3.3. Care and Handling of Regular Expressions
        Section 3.4. Strings, Character Encodings, and Modes
        Section 3.5. Common Metacharacters and Features
        Section 3.6. Guide to the Advanced Chapters
      - Chapter 4. The Mechanics of Expression Processing
        Section 4.1. Start Your Engines!
        Section 4.2. Match Basics
        Section 4.3. Regex-Directed Versus Text-Directed
        Section 4.4. Backtracking
        Section 4.5. More About Greediness and Backtracking
        Section 4.6. NFA, DFA, and POSIX
        Section 4.7. Summary
      - Chapter 5. Practical Regex Techniques
        Section 5.1. Regex Balancing Act
        Section 5.2. A Few Short Examples
        Section 5.3. HTML-Related Examples
        Section 5.4. Extended Examples
      - Chapter 6. Crafting an Efficient Expression
        Section 6.1.
        Section 6.2. A Sobering Example
        Section 6.3. A Global View of Backtracking
        Section 6.4. Benchmarking
        Section 6.5. Common Optimizations
        Section 6.6. Techniques for Faster Expressions
        Section 6.7. Unrolling the Loop
        Section 6.8. The Freeflowing Regex
        Section 6.9. In Summary: Think!
      - Chapter 7. Perl
        Section 7.1. Regular Expressions as a Language Component
        Section 7.2. Perl's Regex Flavor
        Section 7.3. Regex-Related Perlisms
        Section 7.4. The qr/?/ Operator and Regex Objects
        Section 7.5. The Match Operator
        Section 7.6. Fun with Perl Enhancements
        Section 7.7. Perl Efficiency Issues
        Section 7.8. Regex Compilation, the /o Modifier, qr/?/, and Efficiency
        Section 7.9. Final Comments
      - Chapter 8. Java
        Section 8.1. Java's Regex Flavor
        Section 8.2. Using java.util.regex
        Section 8.3. The Pattern.compile() Factory
        Section 8.4. The Matcher Object
        Section 8.5. Other Matcher Methods
        Section 8.6. Other Pattern Methods
        Section 8.7. Pattern's split Method, with Two Arguments
        Section 8.8. Additional Examples
        Section 8.9. Validating HTML with Multiple Patterns Per Matcher
        Section 8.10. Java Version Differences
      - Chapter 9. .NET
        Section 9.1. .NET's Regex Flavor
        Section 9.2. Using .NET Regular Expressions
        Section 9.3. Core Object Details
        Section 9.4. Static "Convenience" Functions
        Section 9.5. Support Functions
        Section 9.6. Advanced .NET
      - Chapter 10. PHP
        Section 10.1. PHP's Regex Flavor
        Section 10.2. The Preg Function Interface
        Section 10.3. The Preg Functions
        Section 10.4. "Missing" Preg Functions
        Section 10.5. Recursive Expressions
        Section 10.6. PHP Efficiency Issues
        Section 10.7. Extended Examples
- Dev IDEs
  - Visual Studio 2005
    - Microsoft E-Learning
      - Mircosoft E-Learning Clinic 2551: Introduction to Visual Studio Team System
      - Mircosoft E-Learning Course 4336: Upgrading from Microsoft® Visual Basic® 6.0: Introduction to the Microsoft .NET Framework
      - Mircosoft E-Learning Course 2924: Building Data Components in Microsoft® Visual Studio® 2005
  - Eclipse
    - Eclipse Distilled
      - Part 1. Getting Started
        Chapter 1. A Java IDE and So Much More!
        Section 1.1. Eclipse Platform Architecture
        Section 1.2. Other Eclipse Projects
        Section 1.3. Agile Development with Eclipse
        Section 1.4. Sample Application
        Section 1.5. Distilled
        Section 1.6. References
        Chapter 2. Hello Eclipse
        Section 2.1. Installation and Startup
        Section 2.2. Eclipse IDE Workbench
        Section 2.3. Create a New Java Project
        Section 2.4. Run Your Application
        Section 2.5. Distilled
        Chapter 3. Managing Your Projects
        Section 3.1. Your Project Workspace
        Section 3.2. Eclipse Resources
        Section 3.3. Planning Projects and Dependencies
        Section 3.4. Distilled
        Chapter 4. Customizing Your Workbench
        Section 4.1. Perspectives
        Section 4.2. Workbench Views
        Section 4.3. Resource Editors
        Section 4.4. Preferences: Have It Your Way
        Section 4.5. Individual and Team Preferences
        Section 4.6. Distilled
        Chapter 5. Rapid Development
        Section 5.1. Expanding the Product Catalog Design
        Section 5.2. Dynamic Duo: Editor and Outline
        Section 5.3. Using Content Assist
        Section 5.4. Using Quick Fix
        Section 5.5. Generate Getters and Setters
        Section 5.6. Exploring Hierarchies
        Section 5.7. Distilled
        Chapter 6. Java Project Configuration
        Section 6.1. Java Build Path
        Section 6.2. Create Shared User Libraries
        Section 6.3. Java Compiler Settings
        Section 6.4. Create Code Templates for Logging
        Section 6.5. Distilled
        Section 6.6. References
        Chapter 7. Debugging Your Code
        Section 7.1. Start a Debug Session
        Section 7.2. Inspecting and Displaying State
        Section 7.3. Managing Debug Sessions
        Section 7.4. Remote Java Applications
        Section 7.5. Distilled
      - Part 2. Getting Agile
        Chapter 8. Characteristics of Agile Development
        Section 8.1. The Agile Manifesto
        Section 8.2. Iterative Development
        Section 8.3. Agile Development and Eclipse
        Section 8.4. Distilled
        Section 8.5. References
        Chapter 9. Updating the Eclipse IDE
        Section 9.1. Finding and Installing Features
        Section 9.2. Installing Plug-ins Without Features
        Section 9.3. Setting Update Preferences
        Section 9.4. Distilled
        Section 9.5. Contributions
        Chapter 10. Continuous Testing with JUnit
        Section 10.1. Choosing a Test Strategy
        Section 10.2. Project Configuration
        Section 10.3. Writing Test Cases
        Section 10.4. Running Your Tests
        Section 10.5. Distilled
        Section 10.6. Contributions
        Section 10.7. References
        Chapter 11. Refactoring Your Code
        Section 11.1. When to Refactor
        Section 11.2. Refactoring in Action
        Section 11.3. Catalog of Refactoring Commands
        Section 11.4. Distilled
        Section 11.5. References
        Chapter 12. Continuous Integration with Ant
        Section 12.1. Automatic Incremental Build
        Section 12.2. Customized Build with Ant
        Section 12.3. Ant Editor and Outline
        Section 12.4. Running Ant in Eclipse
        Section 12.5. Building and Testing Complete Projects
        Section 12.6. Distilled
        Section 12.7. Contributions
        Section 12.8. References
        Chapter 13. Team Ownership with CVS
        Section 13.1. Team Programming with CVS
        Section 13.2. Sharing Your Projects
        Section 13.3. Check Out Projects from CVS
        Section 13.4. Synchronizing with the Repository
        Section 13.5. Managing Versions
        Section 13.6. Creating and Applying Patches
        Section 13.7. Distilled
        Section 13.8. Contributions
        Section 13.9. References
        Chapter 14. Coding Standards
        Section 14.1. Coding Java with Style
        Section 14.2. Auditing Compliance
        Section 14.3. Distilled
        Section 14.4. Contributions
        Section 14.5. References
    - Eclipse IDE Pocket Guide
      - Chapter 1. Introduction
        Section 1.1. What Is Eclipse?
        Section 1.2. Conventions Used in This Book
        Section 1.3. System Requirements
        Section 1.4. Downloading Eclipse
        Section 1.5. Installing Eclipse
        Section 1.6. Exploring Eclipse
        Section 1.7. Getting Upgrades
        Section 1.8. Moving On
      - Chapter 2. Workbench 101
        Section 2.1. Views
        Section 2.2. Editors
        Section 2.3. Menus
        Section 2.4. Toolbars and Coolbars
        Section 2.5. Perspectives
        Section 2.6. Rearranging Views and Editors
        Section 2.7. Maximizing and Minimizing
      - Chapter 3. Java Done Quick
        Section 3.1. Creating a Project
        Section 3.2. Creating a Package
        Section 3.3. Creating a Class
        Section 3.4. Entering Code
        Section 3.5. Running the Program
      - Chapter 4. Debugging
        Section 4.1. Running the Debugger
        Section 4.2. Setting Breakpoints
        Section 4.3. Single Stepping
        Section 4.4. Looking at Variables
        Section 4.5. Changing Code on the Fly
      - Chapter 5. Unit Testing with JUnit
        Section 5.1. A Simple Factorial Demo
        Section 5.2. Creating Test Cases
        Section 5.3. Running Tests
        Section 5.4. Test First
      - Chapter 6. Tips and Tricks
        Section 6.1. Code Assist
        Section 6.2. Templates
        Section 6.3. Automatic Typing
        Section 6.4. Refactoring
        Section 6.5. Hover Help
        Section 6.6. Hyperlinks
        Section 6.7. Quick Fixes
        Section 6.8. Searching
        Section 6.9. Scrapbook Pages
        Section 6.10. Java Build Path
        Section 6.11. Launch Configurations
      - Chapter 7. Views
        Section 7.1. Breakpoints View
        Section 7.2. Console View
        Section 7.3. Debug View
        Section 7.4. Declaration View
        Section 7.5. Display View
        Section 7.6. Error Log View
        Section 7.7. Expressions View
        Section 7.8. Hierarchy View
        Section 7.9. Javadoc View
        Section 7.10. JUnit View
        Section 7.11. Navigator View
        Section 7.12. Outline View
        Section 7.13. Package Explorer View
        Section 7.14. Problems View
        Section 7.15. Search View
        Section 7.16. Tasks View
        Section 7.17. Variables View
      - Chapter 8. Short Takes
        Section 8.1. CVS
        Section 8.2. Ant
        Section 8.3. Web Tools Platform
        Section 8.4. Testing and Performance
        Section 8.5. Visual Editor
        Section 8.6. C/C++ Development
        Section 8.7. AspectJ
        Section 8.8. Plug-in Development
        Section 8.9. Rich Client Platform
        Section 8.10. Standard Widget Toolkit
      - Chapter 9. Help and Community
        Section 9.1. Online Help
        Section 9.2. Eclipse Web Site
        Section 9.3. Community Web Sites
        Section 9.4. Reporting Bugs
        Section 9.5. Newsgroups
        Section 9.6. Mailing Lists
        Section 9.7. Conclusion
      - Appendix A. Commands
        Section A.1. Edit Commands
        Section A.2. File Commands
        Section A.3. Help Commands
        Section A.4. Navigate Commands
        Section A.5. Perspective Commands
        Section A.6. Project Commands
        Section A.7. Refactor Commands
        Section A.8. Run/Debug Commands
        Section A.9. Search Commands
        Section A.10. Source Commands
        Section A.11. Text-Editing Commands
        Section A.12. View Commands
        Section A.13. Window Commands
    - Eclipse Rich Client Platform: Designing, Coding, and Packaging Java™ Applications
      - Part I: Introduction
        Chapter 1. Eclipse as a Rich Client Platform
        Section 1.1. Eclipse
        Section 1.2. The Eclipse Rich Client Platform
        Section 1.3. Eclipse RCP Over the Years
        Section 1.4. Uses of RCP
        Section 1.5. Summary
        Chapter 2. Eclipse RCP Concepts
        Section 2.1. A Community of Plug-ins
        Section 2.2. Inside Plug-ins
        Section 2.3. Putting a System Together
        Section 2.4. OSGi Framework
        Section 2.5. The Runtime
        Section 2.6. SWT
        Section 2.7. JFace
        Section 2.8. UI Workbench
        Section 2.9. Summary
      - Part II: RCP by Example
        Chapter 3. Tutorial Introduction
        Section 3.1. What Is Hyperbola?
        Section 3.2. The Evolution of Hyperbola
        Section 3.3. Development Environment Installation
        Section 3.4. Target Setup
        Section 3.5. Checkpoint
        Section 3.6. Sample Code
        Section 3.7. Learning by Example
        Section 3.8. Summary
        Chapter 4. The Hyperbola Application
        Section 4.1. Hyperbola Hello World
        Section 4.2. Tour of the Code
        Section 4.3. Running and Debugging
        Section 4.4. Summary
        Chapter 5. Starting the Hyperbola Prototype
        Section 5.1. Continuing from the Shell
        Section 5.2. Adding a Contacts View
        Section 5.3. The Chat Model
        Section 5.4. Filling in the Contacts View
        Section 5.5. Adding Images
        Section 5.6. Summary
        Section 5.7. Pointers
        Chapter 6. Adding Actions
        Section 6.1. Adding to the Menus and Toolbar
        Section 6.2. Adding to the Status Line
        Section 6.3. System Tray Integration
        Section 6.4. Summary
        Section 6.5. Pointers
        Chapter 7. Adding a Chat Editor
        Section 7.1. Views and Editors
        Section 7.2. Defining the Chat Editor
        Section 7.3. Checkpoint
        Section 7.4. Summary
        Section 7.5. Pointers
        Chapter 8. Branding Hyperbola
        Section 8.1. Defining the Hyperbola Product
        Section 8.2. Window Images
        Section 8.3. Customizing the Launcher
        Section 8.4. Splash Screen
        Section 8.5. About Information
        Section 8.6. Summary
        Chapter 9. Packaging Hyperbola
        Section 9.1. Exporting Hyperbola
        Section 9.2. Exporting for Other Platforms
        Section 9.3. Summary
        Section 9.4. Pointers
        Chapter 10. Messaging Support
        Section 10.1. Integrating a Third-Party Library
        Section 10.2. Refactoring the Model
        Section 10.3. Updating the UI
        Section 10.4. Chatting with Eliza
        Section 10.5. Summary
        Chapter 11. Adding a Login Dialog
        Section 11.1. Adding the Login Dialog
        Section 11.2. Remembering Login Settings
        Section 11.3. Adding Auto-login Preferences
        Section 11.4. Summary
        Chapter 12. Adding Key Bindings
        Section 12.1. Defining Commands
        Section 12.2. Checkpoint
        Section 12.3. Adding Key Bindings for Workbench Actions
        Section 12.4. Key Configurations
        Section 12.5. Keys Preference Page
        Section 12.6. Summary
        Chapter 13. Adding Help
        Section 13.1. Adding to the Target Platform
        Section 13.2. Getting the Help Plug-ins
        Section 13.3. Configuring the Help Plug-ins
        Section 13.4. Add the Help Action
        Section 13.5. Adding Help Content
        Section 13.6. Help Content Structure
        Section 13.7. Infopops or F1 Help
        Section 13.8. Exporting Plug-ins with Help
        Section 13.9. Summary
        Section 13.10. Pointers
        Chapter 14. Adding Update
        Section 14.1. Getting Update Plug-ins
        Section 14.2. Configuring the Update Plug-ins
        Section 14.3. Defining Features
        Section 14.4. Branding Features
        Section 14.5. Adding Update Actions
        Section 14.6. Automatic Updates
        Section 14.7. Summary
      - Part III: The Workbench
        Chapter 15. Workbench Advisors
        Section 15.1. What Is an Advisor?
        Section 15.2. WorkbenchAdvisor
        Section 15.3. WorkbenchWindowAdvisor
        Section 15.4. ActionBarAdvisor
        Section 15.5. Workbench Overview
        Section 15.6. Summary
        Chapter 16. Perspectives, Views, and Editors
        Section 16.1. Perspectives
        Section 16.2. Views and Editors
        Section 16.3. Multiple Workbench Windows
        Section 16.4. Drag and Drop with Editors
        Section 16.5. Summary
        Chapter 17. Actions
        Section 17.1. Overview
        Section 17.2. Declarative Actions in Hyperbola
        Section 17.3. Standard Workbench Actions
        Section 17.4. Retargetable Actions
        Section 17.5. Consolidating Declarative Actions
        Section 17.6. Toolbar Action Tricks
        Section 17.7. Adding Contributions to the Status Line
        Section 17.8. Reporting Progress
        Section 17.9. Summary
        Chapter 18. Customizing Workbench Windows
        Section 18.1. Customization Defined
        Section 18.2. Customizing a Workbench Window
        Section 18.3. Custom Window Shapes
        Section 18.4. Summary
        Chapter 19. Customizing the Presentation of Views and Editors
        Section 19.1. Presentations
        Section 19.2. Sample Presentations
        Section 19.3. Writing a Presentation
        Section 19.4. Example Presentation
        Section 19.5. Summary
      - Part IV: Development Processes
        Chapter 20. Integrating Code Libraries
        Section 20.1. Plug-ins as JARs
        Section 20.2. Bundling by Injection
        Section 20.3. Bundling by Wrapping
        Section 20.4. Bundling by Reference
        Section 20.5. Troubleshooting Classloading Problems
        Section 20.6. Summary
        Chapter 21. Installing and Updating Plug-ins
        Section 21.1. Update's Roles
        Section 21.2. Features
        Section 21.3. Creating and Managing Update Sites
        Section 21.4. Example: Dynamic Content Handling
        Section 21.5. Summary
        Section 21.6. Pointers
        Chapter 22. Dynamic Plug-ins
        Section 22.1. Making Hyperbola Dynamic
        Section 22.2. Dynamic Challenges
        Section 22.3. Dynamic-awareness
        Section 22.4. Dynamic-enablement
        Section 22.5. Summary
        Chapter 23. RCP Everywhere
        Section 23.1. Sample Code
        Section 23.2. The Scenario
        Section 23.3. Product Configurations
        Section 23.4. Hyperbola Product Configurations
        Section 23.5. Code Structure
        Section 23.6. Designing a Platform
        Section 23.7. RCP-friendly Plug-ins
        Section 23.8. Summary
        Chapter 24. Building Hyperbola
        Section 24.1. What Is PDE Build?
        Section 24.2. Plug-in build.properties
        Section 24.3. Feature build.properties
        Section 24.4. Setting Up a Hyperbola Builder
        Section 24.5. Running the Builder
        Section 24.6. Building Products
        Section 24.7. Cross-platform Building
        Section 24.8. Tweaking the Build
        Section 24.9. Summary
        Chapter 25. The Last Mile
        Section 25.1. Archives
        Section 25.2. Native Installers
        Section 25.3. Java Web Start (JNLP)
        Section 25.4. Update Sites
        Section 25.5. Initializing the Install
        Section 25.6. Pre-initialized Configurations
        Section 25.7. Multi-user Install Scenarios
        Section 25.8. Summary
        Section 25.9. Pointers
      - Part V: Reference
        Chapter 26. OSGi Essentials
        Section 26.1. OSGi and the Eclipse Runtime
        Section 26.2. The Shape of Plug-ins
        Section 26.3. Fragments
        Section 26.4. Version Numbering
        Section 26.5. Services
        Section 26.6. Singletons
        Section 26.7. Bundle Lifecycle
        Section 26.8. Early Activation
        Section 26.9. Auto-activation
        Section 26.10. Classloading
        Section 26.11. Data Areas
        Section 26.12. Putting It All Together
        Section 26.13. Summary
        Chapter 27. Eclipse.org Plug-ins
        Section 27.1. Where to Find Plug-ins
        Section 27.2. Eclipse Platform Plug-ins
        Section 27.3. Product Introduction
        Section 27.4. Resources
        Section 27.5. Text Editing
        Section 27.6. Consoles
        Section 27.7. Variables
        Section 27.8. Outline and Property Views
        Section 27.9. Forms
        Section 27.10. Browser
        Section 27.11. Summary
- OS
  - Linux / UNIX
    - SUSE™ Linux 10 Unleashed
      - Part I: Installation and Configuration
        Chapter 1. Welcome to SUSE Linux
        What Is SUSE Linux?
        Getting Help: Documentation and Other Sources
        References
        Chapter 2. Preparing to Install SUSE Linux
        Planning Your SUSE Linux Installation
        System Requirements
        References
        Chapter 3. Installing SUSE Linux
        Methods of Installing SUSE Linux
        Preparing to Install from a CD-ROM or DVD
        Installing SUSE Linux with YaST
        Logging In and Shutting Down the First Time
        References
        Chapter 4. Further Configuration with YaST and SaX2
        Troubleshooting Installation Problems
        Configuring Hardware with YaST
        Setting Date and Time
        Power Management
        Portable PC Issues
        Configuring CD, DVD, and Rewritable Drives
        References
      - Part II: Using SUSE Linux
        Chapter 5. Getting Started with SUSE Linux
        Logging In to SUSE Linux
        Working with the Linux File System
        Essential File System Commands from the /bin and /sbin Directories
        Using the /boot and /dev Directories
        Editing Configuration Files in the /etc Directory
        Where All the Good Stuff Goes: Your /home Directory
        Finding Desktop Programs in /opt
        Where Most of the Programs Go: The /usr Directory
        Variable Data: The /var Directory
        Changing User Information and the Finger Program
        Choosing and Using a Shell
        Editing Text
        Why Can't I Edit This File? How Permissions Work
        Working as Root
        References
        Chapter 6. Launching Your Desktop
        Understanding the X Window System
        Choosing a Desktop Environment: KDE and GNOME
        Managing Files from Your Desktop
        Configuring Your Desktop Environment
        What Is a Window Manager and Why Would I Want to Use It?
        References
        Chapter 7. Printing with SUSE Linux
        Printing: An Overview
        Common Unix Printing System (CUPS)
        Configuring Printers with YaST
        Configuring CUPS and Network Printers with KDEPrint
        Printing with CUPS
        Working with the Portable Document Format (PDF)
        Console Print Control
        Avoiding Printing Problems
        References
        Chapter 8. Shaking Hands with Your Shell
        The Power of the Command Line
        Writing a Shell Script: The Basics
        Scripting in bash
        Variables in Shell Scripts
        Positional Parameters
        Built-In Variables
        References
        Chapter 9. Being Productive: Office Suites and Other Tools
        Comparing Linux Office Suites
        PDA Connectivity
        More Tools to Make You Productive
        References
        Chapter 10. Sights, Sounds, and Other Fun Things
        Starting Out: Configuring Your Sound and Video Cards
        Playing Music and Listening to the Radio
        Making Your Own Music
        Burning CDs and DVDs
        TV and Video: Xine and Mplayer
        Linux and Your Digital Camera
        Editing Images with The GIMP
        Gaming on Linux
        References
        Chapter 11. Going Cross-Platform
        Viewing Files from the Windows Side of Your Computer
        Emulating Other Operating Systems in Linux: An Overview
        Using Wine to Run Windows Applications
        Running Windows Applications with Win4Lin
        Running Windows Applications with VMware
        Emulating a Mac with Basilisk II
        Using dosemu and DOSBox
        Xen: The Future of Virtualization?
        References
      - Part III: Using the Internet
        Chapter 12. Connecting to the Internet
        Basic Connectivity Information
        Starting with a localhost Interface
        Configuring Your Dial-up Internet Connection
        Configuring a Digital Subscriber Line (DSL) Connection
        Connecting Your Computer to a Wireless Network
        When to Call Your Internet Service Provider
        References
        Chapter 13. Using the Internet: Browsing the Web and Writing Email
        Choosing a Web Browser
        Setting Up Your SUSE Linux Email Account
        Choosing a Mail Client (Mail User Agent)
        Sending File Attachments
        References
        Chapter 14. Creating Basic Websites
        Choosing a Web Development Tool
        Practice: Building a Site with Quanta Plus
        Weblogging with SUSE Linux
        References
        Chapter 15. Managing Email Servers
        How Email Works
        MTA Configuration
        Fighting Spam and Viruses
        Alternatives to Postfix
        References
        Chapter 16. Collaborating with Others
        Usenet News Today
        Choosing a Usenet Newsreader
        Collaborating with Wikis
        Hosting Electronic Mailing Lists
        Working with Instant Messengers and Internet Relay Chat
        Linux Videoconferencing
        References
        Chapter 17. Secure File Transfer
        Choosing a File Transfer Protocol (FTP) Client
        Peer-to-Peer File Transfer
        Building an FTP Server
        Configuring xinetd for Secure File Transfer
        Configuring Secure File Transfer Servers
        References
      - Part IV: Basic System Administration
        Chapter 18. Managing Files, Volumes, and Drives
        Choosing a File System
        Creating and Managing File Systems with Expert Partitioner
        Mounting a File System
        Logical Volume Management (LVM)
        Finding Files
        File System Manipulation
        Managing Files for Character Devices, Block Devices, and Special Devices
        References
        Chapter 19. Managing Users, Managing Security
        User Accounts and Permissions
        Who Needs What? Managing Groups
        Passwords: The First Line of Security
        Monitoring User Activity
        Letting Mortals Play at Wizardry: SuperUsers
        References
        Chapter 20. Managing Data: Backup, Restoring, and Recovery
        Preparing for Preventing Data Loss
        Choosing Your Backup Medium
        Using YaST System Backup
        Backup Software
        Setting Up Mirror Disks and RAID Arrays
        Rescuing a Broken System
        References
        Chapter 21. Keeping Your System Current: Package Management
        Installing Software with YaST
        The Basics of the Red Hat Package Management System (RPM)
        Updating Your System with YaST Online Update (YOU)
        Updating Your System with apt
        Updating Your System with Red Carpet
        Compiling Software from Source
        References
      - Part V: Advanced System Administration
        Chapter 22. Managing the Boot Process and Other Services
        Understanding the Boot Process
        System Services and Runlevels
        Controlling Services at Boot with the YaST Runlevel Editor
        Manually Starting and Stopping Services
        System Monitoring Tools
        References
        Chapter 23. Securing Your Machines
        Understanding Computer Attacks
        Assessing Your Vulnerability
        Protecting Your Machine
        Configuring the SUSE Firewall
        Other Security Utilities to Consider
        What to Do if You've Been Hacked
        Keeping Up to Date on Linux Security Issues
        References
        Chapter 24. Kernel and Module Management
        Linus's Baby: The Linux Kernel
        Managing Modules
        When to Recompile
        Kernel Versions
        Getting New Kernel Sources
        Patching the Kernel
        Compiling the Kernel
        Troubleshooting Problems
        Kernel Tuning with sysctl
        References
        Chapter 25. Setting Up Networks and Samba
        Networking with TCP/IP
        Network Organization
        Hardware Devices in Networking
        Dynamic Host Configuration Protocol (DHCP)
        Using the Network File System
        Playing Nice with Microsoft Windows with Samba
        Securing Network Services
        References
        Chapter 26. Managing Your Apache Web Server
        What Is Apache?
        Installing Apache
        Starting and Stopping Apache
        Runtime Server Configuration Settings
        File System Authentication and Access Control
        Apache Modules
        Virtual Hosting
        Dynamic Content
        Other Web Servers
        References
        Chapter 27. Managing Domain Names
        Essential DNS Concepts
        DNS Hierarchy
        Configuring DNS with YaST2
        Hosts File
        Basic DNS Tools
        Configuring Name Servers with BIND
        Logging
        Summary
        References
      - Part VI: Programming
        Chapter 28. Using the GNU Compiler Collection and Other Programming Tools
        Basic Programming in C Under Linux
        Using the GNU Compiler Collection
        Building Java Applications with Eclipse
        Using the KDevelop Integrated Development Environment
        Using Anjuta to Create GNOME Applications
        Managing Collective Software Development with CVS and Subversion
        Creating RPM Packages
        Other Linux Programming Resources
        References
        Chapter 29. Managing Databases
        What Is a Relational Database?
        Implementing MySQL
        Connecting to a MySQL Database with a Database Client
        Optimizing MySQL
        Summary
        References
        Chapter 30. Using Perl and Python
        What Is Perl?
        Perl Variables and Data Structures
        Operators and Other Statements
        Regular Expressions
        Perl Modules and CPAN
        The Future of Perl
        What Is Python?
        Python Variables and Data Structures
        Indentation
        Extreme Object Orientation
        Python IDEs and the Interactive Shell
        References
        Chapter 31. Creating Dynamic Websites
        Using PHP
        Setting Up an Interactive Site with WordPress
        Setting Up a Web-Based Community Forum
        References
        Chapter 32. Performance Tuning
        Optimizing Services
        Using PowerTweak
        Tuning Hard Disk Drives
        References
        Chapter 33. Command-Line Master Class
        Some Basic Commands
        Combining Commands Together
        References
      - Part VII: Appendices
        Appendix A. Versions of Novell's SUSE Linux
        SUSE Linux 10
        SUSE Linux Enterprise Server (SLES)
        Novell Linux Desktop (NLD)
        Open Enterprise Server (OES)
        Appendix B. SUSE and Linux Internet Resources
        Novell SUSE Linux Reference
        Mailing Lists
        Unix General Reference
        General Linux Resources
        Linux News Reference
        Linux Search Reference
        General Web Link Reference
        Linux Networking and Security Reference
        LAMP and Other Programming References
        Worldwide Linux Newsgroups
  - Windows
    - Learning Windows Server 2003 by Jonathan Hassell Publisher: O'Reilly Pub Date: December 2004 More recent edition of this book available. Print ISBN-10: 0-596-00624-1 Print ISBN-13: 978-0-59-600624-2 Pages: 671
      - Chapter 1. Introducing Windows Server 2003
        Section 1.1. Changes in This Release
        Section 1.2. Windows Server 2003 Editions
        Section 1.3. Hardware Requirements
        Section 1.4. Assessing the Release
      - Chapter 2. Installation and Deployment
        Section 2.1. Preparing to Install Windows Server 2003
        Section 2.2. Choosing Windows Components
        Section 2.3. Installing Windows Server 2003
        Section 2.4. Upgrading Previous and Existing Installations
        Section 2.5. Troubleshooting an Installation
        Section 2.6. Running an Unattended Installation
      - Chapter 3. File and Print Services
        Section 3.1. New File and Print Server Features
        Section 3.2. Setting Up File Sharing Services
        Section 3.3. NTFS File and Folder Permissions
        Section 3.4. Limiting Use of Disk Space with Quotas
        Section 3.5. Using Offline Files and Folders
        Section 3.6. Using Shadow Copies
        Section 3.7. Backing Up Your Machines
        Section 3.8. Using the Encrypting File System
        Section 3.9. The Distributed File System
        Section 3.10. Understanding Print Sharing Services
      - Chapter 4. Domain Name System
        Section 4.1. Nuts and Bolts
        Section 4.2. Zones Versus Domains
        Section 4.3. Resource Records
        Section 4.4. Using Primary and Secondary Nameservers
        Section 4.5. Building a Nameserver
        Section 4.6. Subdomains and Delegation
        Section 4.7. Dynamic DNS
        Section 4.8. Active Directory-Integrated Zones
        Section 4.9. Forwarding
        Section 4.10. The Split DNS Architecture
        Section 4.11. Backup and Recovery
        Section 4.12. Next Steps
      - Chapter 5. Active Directory
        Section 5.1. Active Directory Objects and Concepts
        Section 5.2. Building an Active Directory Structure
        Section 5.3. Understanding Operations Master Roles
        Section 5.4. Understanding Directory Replication
        Section 5.5. Migrating to Active Directory in Windows Server 2003
        Section 5.6. Active Directory Maintenance
        Section 5.7. Conclusion
      - Chapter 6. Group Policy and IntelliMirror
        Section 6.1. An Introduction to Group Policy
        Section 6.2. Group Policy Implementation
        Section 6.3. Group Policy Management Tools
        Section 6.4. Local Group Policy
        Section 6.5. Domain Group Policy
        Section 6.6. Deployment Considerations
        Section 6.7. Troubleshooting Group Policy
        Section 6.8. Conclusion
      - Chapter 7. Windows Security and Patch Management
        Section 7.1. Understanding Security Considerations
        Section 7.2. Creating and Enforcing Security Policies
        Section 7.3. Locking Down Windows
        Section 7.4. Using Auditing and the Event Log
        Section 7.5. About Software Update Services
      - Chapter 8. Internet Information Services
        Section 8.1. IIS Architecture
        Section 8.2. IIS Components
        Section 8.3. What's New in IIS 6
        Section 8.4. Installing IIS
        Section 8.5. Managing Web Services
        Section 8.6. File Transfer Protocol Services
        Section 8.7. SMTP Services
        Section 8.8. The POP3 Server
        Section 8.9. Network News Services
        Section 8.10. Backing Up Your IIS Configuration
        Section 8.11. Automating IIS Administration
        Section 8.12. Securing it All
      - Chapter 9. .NET Framework
        Section 9.1. What Is .NET?
        Section 9.2. What's New in .NET
        Section 9.3. Application Types
        Section 9.4. XML-Based Configuration
        Section 9.5. Security
        Section 9.6. Assemblies
        Section 9.7. Deployment Models
        Section 9.8. Diagnostics
        Section 9.9. Management Tools
        Section 9.10. Reference
      - Chapter 10. Windows Terminal Services
        Section 10.1. The Remote Desktop Protocol
        Section 10.2. Requirements for Terminal Services
        Section 10.3. Adding the Terminal Server Role
        Section 10.4. Enabling Remote Desktop
        Section 10.5. On the User's Side
        Section 10.6. Installing an Application
        Section 10.7. Configuring Terminal Services Licensing
        Section 10.8. Terminal Services Administration
        Section 10.9. Command-Line Management
      - Chapter 11. Communications and Networking
        Section 11.1. Dynamic Host Configuration Protocol
        Section 11.2. Virtual Private Networks
        Section 11.3. IP Security
        Section 11.4. Network Access Quarantine Control
        Section 11.5. Conclusion
      - Chapter 12. Clustering Technologies
        Section 12.1. Network Load-Balancing Clusters
        Section 12.2. True Server Clusters
        Section 12.3. Conclusion
      - Chapter 13. Other Windows Server 2003 Services
        Section 13.1. The Indexing Service
        Section 13.2. The Microsoft Message Queue
        Section 13.3. Feature Packs and Add-Ons
      - Appendix A. The Future of Windows Server 2003
        Section A.1. Service Pack 1
        Section A.2. Windows Server 2003 "R2"
- Design
  - Spring Into HTML and CSS
    - Chapter 1. Building an HTML Page
      - Declaring and Identifying the Document
        Adding the html Element
        The head and title Elements
      - The meta Element
      - The body Element
      - HTML Comments
      - Reviewing the Template
      - Text Is Next!
    - Chapter 2. Adding Text and Links
      - Using Headers Properly
      - Adding Paragraphs
      - Working with Page Breaks
      - Ordered Lists
      - Unordered Lists
      - Nesting Lists
      - Definition Lists
        The Good Old Link
      - Email Links
      - Intrapage Linking
      - Adding Content to the Template
      - Wrapping It Up
    - Chapter 3. Adding Images, Media, and Scripts
      - The img Element
      - Adding width and height Values
      - Providing Alternative Text
      - Linking the Image
      - Linking to an Audio or Video File
        Embedding Files Using the object Element
        But Your Honor, I Object!
      - Adding Scripts
        Scripting and Browser Concerns
      - Imagine That!
    - Chapter 4. Creating Tables
      - The table Element
      - Adding a Table Row
        Adding Table Cells
      - Adding Table Headers
      - Adding a Caption
        Table Summaries
      - Spanning Rows
        Spanning Columns
        Combining colspan and rowspan
      - Grouping Table Columns: The col Element
      - Grouping Table Columns with colgroup
      - Grouping Table Rows
      - The Table's Set…
    - Chapter 5. Building Forms
      - The form Element
      - Adding an Input Textbox
      - Adding Check Boxes and Radio Buttons
      - Preselecting Checked Items
      - Using Form Menus
      - Working with Text Areas
      - Reset and Submit Buttons
      - Using a Graphic Submit Button
        Making Forms More Accessible with label
      - Grouping Form Fields
      - Grouping Menu Items
      - Customizing and Advancing Your Forms
      - Now That You're Well-Formed…
    - Chapter 6. Working with Frames
      - The Power of Three
      - Creating a Frameset
      - Adding Columns
      - Working with Rows
      - Combining Columns and Rows
        Margin, Resize, and Scroll Controls
        Naming and Targeting Frames
      - Frames Without Frontiers
        Making Frames Accessible with noframes
      - Wonderful Inline Frames
      - You're Framed!
    - Chapter 7. Using CSS
      - CSS Theory Simplified
        Adding Style Inline
      - Using Embedded Style
      - Creating a Linked Style Sheet
        Importing Style Sheets
      - Commenting and Formatting CSS
        Time to Put Your Imagination to Work!
    - Chapter 8. Working with Color and Images Using CSS
      - Color and CSS
        Adding Color to Backgrounds
      - Spicing Up a Table Using Background Color
        Attaching a Background Graphic
        Controlling How Backgrounds Tile
      - Positioning a Background Graphic
      - Fixing and Scrolling Background Images
      - Making a Background Color Transparent
      - CSS Shorthand for Backgrounds
      - Having Fun Yet?
    - Chapter 9. Styling Text
      - Choosing Fonts
      - Applying Font Families to Text
      - Sizing Fonts
      - Font Weight and Style
      - Coloring Text
      - Aligning Text
      - Text Decoration
        Indenting Text
      - Transforming and Varying Text
      - Setting Line Height
      - Spacing Letters and Words
      - Modifying First-Letter and First-Line Text
      - Using Shorthand for Font Styles
        Now You're Getting Fancy!
    - Chapter 10. Link Effects, Lists, and Navigation
      - Working with Link States
      - Modifying Link Styles
      - Multiple Link Styles Using Class Selectors
        Styling Links Using Descendant Selectors
        Styling Ordered Lists
      - Styling Unordered Lists
        Shorthand CSS for List Styles
      - List-Based Vertical Navigation Using Color
      - Vertical List Navigation with Image Effects
        Horizontal List-Based Navigation with Color
      - Horizontal List Navigation with Images
        Rich Links, Lists, and Navigation
    - Chapter 11. Margins, Borders, and Padding
      - Exploring the Box Model
        Using Margins
      - Using Negative Margins
        Margin Shorthand
        Styling Borders
      - Border Shorthand
      - Using Padding
      - Padding Shorthand
      - Toward Gaining More Control…
    - Chapter 12. Positioning, Floats, and Z-index
      - Getting into Position
      - Normal Flow
      - Containing Blocks
      - The Browser Viewport
      - Absolute Positioning: To the Root Element
      - Absolute Positioning: To Another Block
      - Relative Positioning
      - Fixed Positioning
        Floating Elements
      - Clearing Floats
      - Z-index
      - Just Like a Pro…
    - Chapter 13. CSS Layouts
      - Three Columns with Fixed Flanking Menus
      - Three Columns with Masthead and Footer
      - Nested Float
      - Centered Designs
      - Complex Layouts
      - Repeat After Me…
    - Appendix A. XHTML 1.0 Annotated Reference
      - Key to Element Types: Display
      - Key to Element Types: Empty and Non-Empty
    - Appendix B. CSS 2.1 Annotated Reference
      - Selectors, Pseudo Classes, and Pseudo Elements
      - CSS 2.1 Properties
  - The Zen of CSS Design: Visual Enlightenment for the Web
    - Chapter 1. View Source
      - View Source
      - Genesis
      - The Beginning of a Change
      - Why these Standards?
      - Planting the Seed
        Default Design—Tranquille
      - Implications
      - Laying the Foundation
        Semantic Markup
      - Building Great Markup
      - The Test of Time
      - Zen Garden Source HTML
      - Visual Structure
      - Designing For Flexibility
        Lessons Taught
        Benefits of Web Standards
      - Lessons Learned
        Accessibility Checking
      - Text Scalability
      - XHTML and Mime Types
        Foreign Languages
      - Copyright and Theft
        Build it Bigger, Build it Better!
    - Chapter 2. Design
      - Atlantis: Minimal design, unity, and symbolism
        Minimalism
      - Unity and Symbolism
        Design Prerogative
        Zunflower: Playing with light and shadow, shape and space
      - Finding the Light
      - Preserving the Shadow
      - Getting into Shape
      - Give Me My Space!
      - Adding Professional Polish
      - Springtime: Using color to evoke emotion
      - The Influence of Color
      - Color Palettes for Web Sites
        Color Options in CSS
      - Colorful Conclusions
      - Viridity: Balancing pattern, texture, and contrast
      - Pattern
      - Texture
      - Contrast
        Unity
        Ballade: Using the imagination to create visual flow and guide the eye
      - Leading the Eye
        Thinking in CSS
      - Finding the Bridge
      - Night Drive: Converting static site mock-ups to code, and solving problems when doing so
        Visualizing Code
      - Choices
        Absolute-Positioning Trickery
        Sleight of Hand
      - Collapsing Margins
      - Image Trickery
      - One Small Step
    - Chapter 3. Layout
      - Backyard: Understanding absolute positioning and floats
      - Layout Basics
      - Layout Methods
      - Absolutely Complementary
      - Entomology: Centered layouts in contemporary Web design
      - Fixed and Liquid Layouts
      - Getting Centered
      - Staying Stylish
      - White Lily: Principles and process for designing effective layouts
        Layout Principles for the Web
      - Look Before You Leap
      - Layout Solutions in White Lily
      - Layout Inspiration and Guidelines
      - Follow a Process
      - Prêt-à-porter: Exploring horizontal lines in a vertical world
        Print Design as Inspiration
        The Horizontal Challenge
      - Lessons Learned
        CS(S) Monk: Meaningful positioning and understanding the grid
      - Positioning and Meaning
      - The Grid
        Constructing the Grid
      - Breaking Out of the Grid
        Flexibility Within the Grid
        Not So Minimal: Dealing with common overflow problems
      - Content Overflow
      - Float Overflow
      - Absolute-Positioning Overflow
      - Design for the Overflow
    - Chapter 4. Imagery
      - Japanese Garden: Understanding image formats and optimization
      - Image Formats
      - Understanding Image Choices
      - Transparency Limitations
      - Optimization Tricks
      - A Tough Choice
      - Revolution!: Applying images with CSS
      - Practical Application
        Image Replacement
      - Responsible Replacement
      - Better Techniques
      - Choices
      - Deco: Minimal imagery, maximum impact
      - A New Way of Thinking
        Intelligent Approaches to Imagery
        Maximum Impact
      - No Frontiers!: Breaking out of the box using rounded imagery
        The Rectangular Problem
      - Getting Curvy
      - Well-Rounded Imagery
        Coastal Breeze: Creating imagery for your work and finding additional source material
      - The Starting Point
        Techniques
        Creating Imagery
      - Acquiring Imagery
      - Copyright Notes
      - Verdict: The Painted Look
      - What Lies Beneath: Three-dimensional environments in two-dimensional form
      - Creating Environments
      - Unrealistic Imagery in Simulated Environments
      - Dimensional Lessons
    - Chapter 5. Typography
      - Oceans Apart: Simplicity in type leads to lasting, effective design
      - Type Conventions
      - Learning from Simplicity
      - Si6: The trouble with fonts, and how to cope with that trouble
      - Limited Font Choice
        Generic Font Families
      - serif
      - Vanilla's Nice, but...
      - Practical Font Selection
      - Release One: Coming to terms with the insanity that is font sizing
      - Font Size
        Browser Controls
        Relative vs. Absolute
      - Pixels and Problems
        Sane Font Sizing
      - Which Method?
      - Dead or Alive: Grace and gravity in typographic design
        Decorative Flourishes
      - Typographic Layout
        Optical Behavior
        Avoiding Comprehension Problems
      - Thoughtful Type, Graceful Design
      - Blood Lust: Exploring type formatting options
      - Setting the Tone with Type
      - Formatting Options
      - All Things in Moderation
      - Golden Mean: Method and creativity combined to create typographic balance
      - Selecting Type
      - Getting into Typography
        Balance Is Key
    - Chapter 6. Special Effects
      - This is Cereal: The cascade and layering effects
      - The Cascade
      - Layering
        Integration
      - Gemination: Two designs but one style sheet
      - MOSe
      - CSS Signatures
        Comparing MOSe to Internet Explorer Styles
      - Enhanced Gemination
        Future-Proof Design
        Bonsai Sky: Working around browser limitations with creative imagery and code
      - Versioning
        Judgment Calls
      - Tulipe: CSS drop-down menus with an alternative for Internet Explorer
      - Exploring Pure CSS Menus
        Drop-Down Menus in Tulipe
      - Lessons Learned
        Door to my Garden: Simple CSS resulting in impressive, sophisticated visual effects
        Background Savvy
      - Layout Choices
      - Additional Style Effects
      - Great Style, Simple CSS
      - Elastic Lawn: Visual problem solving sometimes goes further than skin-deep
      - Paper or Plastic?
      - Elastic Design
    - Chapter 7. Reconstruction
      - Hedges: Background images blend seamlessly with a variable foreground
      - Setting Boundaries
      - Building Columns
      - Image Tricks
      - Formatting
      - Finishing Up
        Radio Zen: A radio dial made possible with a fixed background image
      - Setting the Stage
      - Layering and Attachment
      - Column Positioning
      - Exploring the Possibilities
      - South of the Border: Corralling content with margins and positioning
        Beginning Basic
        Styling the Container
      - Reining In the Text
        Head 'em Up
      - Now for the Footer
      - Absolute Containment
        Rounding Up the Links
      - Move'em Out
        Corporate ZenWorks: From competition to concord
        Take a Letter
      - Paper, Please
      - Corporate Identity
      - Linking In
      - A Little Personality
      - Send It On
      - Open Window: One design, three layouts
      - The Basics
      - Fixing the Intro
        Up, Down, Left, Right
      - Styling the Content and Links
      - Now for Opera
      - Three in One
      - Mnemonic: Designer tricks for liquid layouts and enhanced effects
      - Problem Solving
        Moving Forward
        Making the Right Choice
    - Closing Thoughts
      - CSS Crib Sheet
      - Other Resources
        Submit Your Own!
  - Designing Interfaces
    - Chapter 1. What Users Do
      - Section 1.1. A MEANS TO AN END
      - Section 1.2. THE BASICS OF USER RESEARCH
      - Section 1.3. USERS' MOTIVATION TO LEARN
      - Section 1.4. THE PATTERNS
    - Chapter 2. Organizing the Content:Information Architecture and Application Structure
      - Section 2.1. THE BASICS OF INFORMATION ARCHITECTURE: DIVIDING STUFF UP
      - Section 2.2. PHYSICAL STRUCTURE
      - Section 2.3. THE PATTERNS
    - Chapter 3. Getting Around:Navigation, Signposts, and Wayfinding
      - Section 3.1. STAYING FOUND
      - Section 3.2. THE COST OF NAVIGATION
      - Section 3.3. THE PATTERNS
    - Chapter 4. Organizing the Page:Layout of Page Elements
      - Section 4.1. THE BASICS OF PAGE LAYOUT
        Section 4.2. THE PATTERNS
    - Chapter 5. Doing Things:Actions and Commands
      - Section 5.1. PUSHING THE BOUNDARIES
      - Section 5.2. THE PATTERNS
    - Chapter 6. Showing Complex Data:Trees, Tables, and Other Information Graphics
      - Section 6.1. THE BASICS OF INFORMATION GRAPHICS
      - Section 6.2. THE PATTERNS
    - Chapter 7. Getting Input from Users:Forms and Controls
      - Section 7.1. THE BASICS OF FORM DESIGN
      - Section 7.2. CONTROL CHOICE
      - Section 7.3. THE PATTERNS
    - Chapter 8. Builders and Editors
      - Section 8.1. THE BASICS OF EDITOR DESIGN
      - Section 8.2. THE PATTERNS
    - Chapter 9. Making It Look Good:Visual Style and Aesthetics
      - Section 9.1. SAME CONTENT, DIFFERENT STYLES
      - Section 9.2. THE BASICS OF VISUAL DESIGN
      - Section 9.3. WHAT THIS MEANS FOR DESKTOP APPLICATIONS
      - Section 9.4. THE PATTERNS
  - Write Great Code by Randall Hyde Publisher: No Starch Pub Date: November 2004 Print ISBN-10: 1-59327-003-8 Print ISBN-13: 978-1-59-327003-2 Pages: 456
    - Chapter 1. WHAT YOU NEED TO KNOW TO WRITE GREAT CODE
      - Section 1.1. The Write Great Code Series
      - Section 1.2. What This Volume Covers
      - Section 1.3. Assumptions This Volume Makes
      - Section 1.4. Characteristics of Great Code
      - Section 1.5. The Environment for This Volume
      - Section 1.6. For More Information
    - Chapter 2. NUMERIC REPRESENTATION
      - Section 2.1. What Is a Number?
      - Section 2.2. Numbering Systems
      - Section 2.3. Numeric/String Conversions
      - Section 2.4. Internal Numeric Representation
      - Section 2.5. Signed and Unsigned Numbers
      - Section 2.6. Some Useful Properties of Binary Numbers
      - Section 2.7. Sign Extension, Zero Extension, and Contraction
      - Section 2.8. Saturation
      - Section 2.9. Binary-Coded Decimal (BCD) Representation
      - Section 2.10. Fixed-Point Representation
      - Section 2.11. Scaled Numeric Formats
      - Section 2.12. Rational Representation
      - Section 2.13. For More Information
    - Chapter 3. BINARY ARITHMETIC AND BIT OPERATIONS
      - Section 3.1. Arithmetic Operations on Binary and Hexadecimal Numbers
      - Section 3.2. Logical Operations on Bits
      - Section 3.3. Logical Operations on Binary Numbers and Bit Strings
      - Section 3.4. Useful Bit Operations
      - Section 3.5. Shifts and Rotates
      - Section 3.6. Bit Fields and Packed Data
      - Section 3.7. Packing and Unpacking Data
      - Section 3.8. For More Information
    - Chapter 4. FLOATING-POINT REPRESENTATION
      - Section 4.1. Introduction to Floating-Point Arithmetic
      - Section 4.2. IEEE Floating-Point Formats
      - Section 4.3. Normalization and Denormalized Values
      - Section 4.4. Rounding
      - Section 4.5. Special Floating-Point Values
      - Section 4.6. Floating-Point Exceptions
      - Section 4.7. Floating-Point Operations
      - Section 4.8. For More Information
    - Chapter 5. CHARACTER REPRESENTATION
      - Section 5.1. Character Data
      - Section 5.2. Character Strings
      - Section 5.3. Character Sets
      - Section 5.4. Designing Your Own Character Set
      - Section 5.5. For More Information
    - Chapter 6. MEMORY ORGANIZATION AND ACCESS
      - Section 6.1. The Basic System Components
      - Section 6.2. Physical Organization of Memory
      - Section 6.3. Big Endian Versus Little Endian Organization
      - Section 6.4. The System Clock
      - Section 6.5. CPU Memory Access
      - Section 6.6. For More Information
    - Chapter 7. COMPOSITE DATA TYPES AND MEMORY OBJECTS
      - Section 7.1. Pointer Types
      - Section 7.2. Arrays
      - Section 7.3. Records/Structures
      - Section 7.4. Discriminant Unions
      - Section 7.5. For More Information
    - Chapter 8. BOOLEAN LOGIC AND DIGITAL DESIGN
      - Section 8.1. Boolean Algebra
      - Section 8.2. Boolean Functions and Truth Tables
      - Section 8.3. Function Numbers
      - Section 8.4. Algebraic Manipulation of Boolean Expressions
      - Section 8.5. Canonical Forms
      - Section 8.6. Simplification of Boolean Functions
      - Section 8.7. What Does This Have to Do with Computers, Anyway?
      - Section 8.8. For More Information
    - Chapter 9. CPU ARCHITECTURE
      - Section 9.1. Basic CPU Design
      - Section 9.2. Decoding and Executing Instructions: Random Logic Versus Microcode
      - Section 9.3. Executing Instructions, Step by Step
      - Section 9.4. Parallelism — The Key to Faster Processing
      - Section 9.5. For More Information
    - Chapter 10. INSTRUCTION SET ARCHITECTURE
      - Section 10.1. The Importance of the Design of the Instruction Set
      - Section 10.2. Basic Instruction Design Goals
      - Section 10.3. The Y86 Hypothetical Processor
      - Section 10.4. Encoding 80x86 Instructions
      - Section 10.5. Implications of Instruction Set Design to the Programmer
      - Section 10.6. For More Information
    - Chapter 11. MEMORY ARCHITECTURE AND ORGANIZATION
      - Section 11.1. The Memory Hierarchy
      - Section 11.2. How the Memory Hierarchy Operates
      - Section 11.3. Relative Performance of Memory Subsystems
      - Section 11.4. Cache Architecture
      - Section 11.5. Virtual Memory, Protection, and Paging
      - Section 11.6. Thrashing
      - Section 11.7. NUMA and Peripheral Devices
      - Section 11.8. Writing Software That Is Cognizant of the Memory Hierarchy
      - Section 11.9. Run-Time Memory Organization
      - Section 11.10. For More Information
    - Chapter 12. INPUT AND OUTPUT (I/O)
      - Section 12.1. Connecting a CPU to the Outside World
      - Section 12.2. Other Ways to Connect Ports to the System
      - Section 12.3. I/O Mechanisms
      - Section 12.4. I/O Speed Hierarchy
      - Section 12.5. System Buses and Data Transfer Rates
      - Section 12.6. Buffering
      - Section 12.7. Handshaking
      - Section 12.8. Time-outs on an I/O Port
      - Section 12.9. Interrupts and Polled I/O
      - Section 12.10. Protected Mode Operation and Device Drivers
      - Section 12.11. Exploring Specific PC Peripheral Devices
      - Section 12.12. The Keyboard
      - Section 12.13. The Standard PC Parallel Port
      - Section 12.14. Serial Ports
      - Section 12.15. Disk Drives
      - Section 12.16. Tape Drives
      - Section 12.17. Flash Storage
      - Section 12.18. RAM Disks and Semiconductor Disks
      - Section 12.19. SCSI Devices and Controllers
      - Section 12.20. The IDE/ATA Interface
      - Section 12.21. File Systems on Mass Storage Devices
      - Section 12.22. Writing Software That Manipulates Data on a Mass Storage Device
      - Section 12.23. The Universal Serial Bus (USB)
      - Section 12.24. Mice, Trackpads, and Other Pointing Devices
      - Section 12.25. Joysticks and Game Controllers
      - Section 12.26. Sound Cards
      - Section 12.27. For More Information
      - THINKING LOW-LEVEL, WRITING HIGH-LEVEL
    - Appendix A. ASCII Character Set
  - UML™ for the IT Business Analyst: A Practical Guide to Object-Oriented Requirements Gathering by Howard Podeswa Publisher: Course Technology Pub Date: 2005 ISBN: 1-59200-912-3 Pages: 400
    - Chapter 1. Who Are IT Business Analysts?
      - Chapter Objectives
      - The IT and Non-IT BA
      - Perspective on the IT BA Role
      - Why Modeling Is a Good Thing
      - The Dynamic (Behavioral) Model
      - The Static (Structural) Model
      - For Those Trained in Structured Analysis
      - Chapter Summary
    - Chapter 2. The BA's Perspective on Object Orientation
      - Chapter Objectives
      - What Is OO?
      - The UML Standard
      - Cognitive Psychology and OO?
      - Objects
      - Attributes and Operations
      - Operations and Methods
      - Encapsulation
      - OO Concept: Classes
      - OO Concept: Relationships
      - OO Concept: Generalization
      - OO Concept: Association
      - OO Concept: Aggregation
      - OO Concept: Composition
      - OO Concept: Polymorphism
      - Use Cases and Scenarios
      - Business and System Use Cases
      - Chapter Summary
    - Chapter 3. An Overview of Business Object-Oriented Modeling (B.O.O.M.)
      - Chapter Objectives
      - B.O.O.M. and SDLCs
      - The B.O.O.M. Steps
      - Sequencing the Steps
      - What Do You Define First—Attributes or Operations?
      - Chapter Summary
    - Chapter 4. Analyzing End-to-End Business Processes
      - Chapter Objectives
      - B.O.O.M. Steps
      - Interviews During the Initiation, Analysis, and Test Phases
      - Step 1: Initiation
      - Business Requirements Document Template
      - Step 1a: Model Business Use Cases
      - Step 1a i: Identify Business Use Cases (Business Use-Case Diagram)
      - Putting Theory into Practice
      - Note to Rational Rose Users
      - Case Study D1: Business Use-Case Diagrams
      - Step 1a ii: Scope Business Use Cases (Activity Diagram)
      - Case Study D2: Business Use-Case Activity Diagram with Partitions
      - Chapter Summary
    - Chapter 5. Scoping the IT Project with System Use Cases
      - Chapter Objectives
      - Step 1b: Model System Use Cases
      - Case Study E1: Role Map
      - Step 1b ii: Identify System Use-Case Packages (System Use-Case Diagram)
      - Case Study E2: System Use-Case Packages
      - Step 1b iii: Identify System Use Cases (System Use-Case Diagram)
      - Case Study E3: System Use-Case Diagrams
      - Step 1c: Begin Static Model (Class Diagrams for Key Business Classes)
      - Step 1d: Set Baseline for Analysis (BRD/Initiation)
      - Chapter Summary
    - Chapter 6. Storyboarding the User's Experience
      - Chapter Objectives
      - Step 2: Analysis
      - The Use-Case Description Template
      - Documenting the Basic Flow
      - Use-Case Writing Guidelines
      - Basic Flow Example: CPP System Review Case Report
      - Documenting Alternate Flows
      - Documenting Exception Flows
      - Guidelines for Conducting System Use-Case Interviews
      - Activity Diagrams for System Use Cases
      - Related Artifacts
      - Decision Tables
      - Case Study F1: Decision Table
      - Decision Trees
      - Case Study F2: Decision Tree
      - Condition/Response Table
      - Business Rules
      - Advanced Use-Case Features
      - Case Study F3: Advanced Use-Case Features
      - Chapter Summary
    - Chapter 7. Life Cycle Requirements for Key Business Objects
      - Chapter Objectives
      - What Is a State Machine Diagram?
      - Step 2a ii: 1. Identify States of Critical Objects
      - Case Study G1: States
      - Step 2a ii: 2. Identify State Transitions
      - Case Study G2: Transitions
      - Step 2a ii: 3. Identify State Activities
      - Case Study G3: State Activities
      - Step 2a ii: 4. Identify Composite States
      - Case Study G4: Composite States
      - Step 2a ii: 5. Identify Concurrent States
      - Chapter Summary
    - Chapter 8. Gathering Across-the-Board Rules with Class Diagrams
      - Chapter Objectives
      - Step 2b: Static Analysis
      - Step 2b i: Identify Entity Classes
      - Case Study H1: Entity Classes
      - Step 2b ii: Model Generalizations
      - Case Study H2: Generalizations
      - Step 2b iii: Model Transient Roles
      - Case Study H3: Transient Roles
      - Step 2b iv: Model Whole/Part Relationships
      - The Composite Structure Diagram
      - Case Study H4: Whole/Part Relationships
      - Step 2b v: Analyze Associations
      - Case Study H5: Associations
      - Step 2b vi: Analyze Multiplicity
      - Case Study H6: Multiplicity
      - Chapter Summary
    - Chapter 9. Optimizing Consistency and Reuse in Requirements Documentation
      - Chapter Objectives
      - Where Do You Go from Here?
      - Step 2b vii: Link System Use Cases to the Static Model
      - Case Study I1: Link System Use Cases to the Static Model
      - Case Study I1: Results
      - Step 2b viii: Add Attributes
      - Meta-Attributes
      - Case Study I2: Add Attributes
      - Step 2b ix: Add Look-Up Tables
      - Case Study I5: Analyze Look-Up Tables
      - Step 2b x: Add Operations
      - Case Study I7: Distribute Operations
      - Step 2b xi: Revise Class Structure
      - Case Study I8: Revise Structure
      - Chapter Summary
    - Chapter 10. Designing Test Cases and Completing the Project
      - Chapter Objectives
      - Step 2c: Specify Testing
      - Structured Walkthroughs
      - Decision Tables for Testing
      - Case Study J1: Deriving Test Cases from Decision Tables
      - Boundary Value Analysis
      - Case Study J2: Select Test Data Using Boundary Value Analysis
      - System Tests
      - Beyond the System Tests
      - Step 2d: Specify Implementation Plan
      - Step 2e: Set Baseline for Development
      - Chapter Summary
    - Chapter 11. What Developers Do with Your Requirements
      - Chapter Objectives
      - OO Patterns
      - Visibility
      - Control Classes
      - Boundary Classes
      - Sequence Diagrams
      - Communication Diagrams
      - Other Diagrams
      - Layered Architecture
      - Interfaces
      - Mix-Ins
      - Implementing OO Using an OO Language
      - Implementing OOA Using Procedural Languages
      - Implementing a Database from OOA Using a RDBMS
      - Chapter Summary
    - Job Aids
      - Appendix A. The B.O.O.M. Process
        Section 1. Initiation
        Section 2. Analysis
      - Appendix B. Business Requirements Document (BRD) Template
      - Appendix C. Business Requirements Document Example: CPP Case Study
      - Appendix D. Decision Table Template
      - Appendix E. Test Script Template
      - Appendix F. Glossary of Symbols
      - Appendix G. Glossary of Terms and Further Reading
        Further Reading
- Misc
  - Hackers & Painters
    - Chapter 1. Why Nerds Are Unpopular
    - Chapter 2. Hackers and Painters
    - Chapter 3. What You Can't Say
      - Section 3.1. The Conformist Test
      - Section 3.2. Trouble
        Section 3.3. Heresy
      - Section 3.4. Time and Space
      - Section 3.5. Prigs
      - Section 3.6. Mechanism
      - Section 3.7. Why
        Section 3.8. Pensieri Stretti
        Section 3.9. Viso Sciolto?
        Section 3.10. Always Be Questioning
    - Chapter 4. Good Bad Attitude
    - Chapter 5. The Other Road Ahead
      - Section 5.1. The Next Thing?
      - Section 5.2. The Win for Users
      - Section 5.3. City of Code
      - Section 5.4. Releases
      - Section 5.5. Bugs
        Section 5.6. Support
        Section 5.7. Morale
        Section 5.8. Brooks in Reverse
      - Section 5.9. Watching Users
      - Section 5.10. Money
      - Section 5.11. Customers
        Section 5.12. Son of Server
        Section 5.13. Microsoft
      - Section 5.14. Startups but More So
        Section 5.15. Just Good Enough
        Section 5.16. Why Not?
    - Chapter 6. How to Make Wealth
      - Section 6.1. The Proposition
      - Section 6.2. Millions, not Billions
        Section 6.3. Money Is Not Wealth
        Section 6.4. The Pie Fallacy
        Section 6.5. Craftsmen
        Section 6.6. What a Job Is
      - Section 6.7. Working Harder
      - Section 6.8. Measurement and Leverage
      - Section 6.9. Smallness = Measurement
      - Section 6.10. Technology = Leverage
        Section 6.11. The Catch(es)
      - Section 6.12. Get Users
        Section 6.13. Wealth and Power
    - Chapter 7. Mind the Gap
      - Section 7.1. The Daddy Model of Wealth
        Section 7.2. Stealing It
      - Section 7.3. The Lever of Technology
        Section 7.4. Alternative to an Axiom
    - Chapter 8. A Plan for Spam
    - Chapter 9. Taste for Makers
    - Chapter 10. Programming Languages Explained
      - Section 10.1. Machine Language
        Section 10.2. High-Level Languages
        Section 10.3. Open Source
        Section 10.4. Language Wars
        Section 10.5. Abstractness
      - Section 10.6. Seat Belts or Handcuffs?
      - Section 10.7. OO
      - Section 10.8. Renaissance
    - Chapter 11. The Hundred-Year Language
    - Chapter 12. Beating the Averages
      - Section 12.1. The Secret Weapon
        Section 12.2. The Blub Paradox
        Section 12.3. Aikido for Startups
    - Chapter 13. Revenge of the Nerds
      - Section 13.1. Catching Up with Math
      - Section 13.2. What Made Lisp Different
        Section 13.3. Where Languages Matter
        Section 13.4. Centripetal Forces
        Section 13.5. The Cost of Being Average
        Section 13.6. A Recipe
      - Section 13.7. Appendix: Power
    - Chapter 14. The Dream Language
      - Section 14.1. The Mechanics of Popularity
      - Section 14.2. External Factors
      - Section 14.3. Succinctness
      - Section 14.4. Hackability
      - Section 14.5. Throwaway Programs
      - Section 14.6. Libraries
      - Section 14.7. Efficiency
        Section 14.8. Time
      - Section 14.9. Redesign
        Section 14.10. The Dream Language
    - Chapter 15. Design and Research
    - Notes
  - The Cathedral & the Bazaar
    - Preface: Why You Should Care
    - Chapter 1. A Brief History of Hackerdom
      - Section 1.1. Prologue: The Real Programmers
      - Section 1.2. The Early Hackers
      - Section 1.3. The Rise of Unix
      - Section 1.4. The End of Elder Days
      - Section 1.5. The Proprietary-Unix Era
      - Section 1.6. The Early Free Unixes
      - Section 1.7. The Great Web Explosion
    - Chapter 2. The Cathedral and the Bazaar
      - Section 2.1. The Cathedral and the Bazaar
      - Section 2.2. The Mail Must Get Through
      - Section 2.3. The Importance of Having Users
      - Section 2.4. Release Early, Release Often
      - Section 2.5. How Many Eyeballs Tame Complexity
      - Section 2.6. When Is a Rose Not a Rose?
      - Section 2.7. Popclient becomes Fetchmail
      - Section 2.8. Fetchmail Grows Up
      - Section 2.9. A Few More Lessons from Fetchmail
      - Section 2.10. Necessary Preconditions for the Bazaar Style
      - Section 2.11. The Social Context of Open-Source Software
      - Section 2.12. On Management and the Maginot Line
      - Section 2.13. Epilog: Netscape Embraces the Bazaar
    - Chapter 3. Homesteading the Noosphere
      - Section 3.1. An Introductory Contradiction
      - Section 3.2. The Varieties of Hacker Ideology
      - Section 3.3. Promiscuous Theory, Puritan Practice
      - Section 3.4. Ownership and Open Source
      - Section 3.5. Locke and Land Title
      - Section 3.6. The Hacker Milieu as Gift Culture
      - Section 3.7. The Joy of Hacking
      - Section 3.8. The Many Faces of Reputation
      - Section 3.9. Ownership Rights and Reputation Incentives
      - Section 3.10. The Problem of Ego
      - Section 3.11. The Value of Humility
      - Section 3.12. Global Implications of the Reputation-Game Model
      - Section 3.13. How Fine a Gift?
      - Section 3.14. Noospheric Property and the Ethology of Territory
      - Section 3.15. Causes of Conflict
      - Section 3.16. Project Structures and Ownership
      - Section 3.17. Conflict and Conflict Resolution
      - Section 3.18. Acculturation Mechanisms and the Link to Academia
      - Section 3.19. Gift Outcompetes Exchange
      - Section 3.20. Conclusion: From Custom to Customary Law
      - Section 3.21. Questions for Further Research
    - Chapter 4. The Magic Cauldron
      - Section 4.1. Indistinguishable From Magic
      - Section 4.2. Beyond Geeks Bearing Gifts
      - Section 4.3. The Manufacturing Delusion
      - Section 4.4. The Information Wants to be Free Myth
      - Section 4.5. The Inverse Commons
      - Section 4.6. Reasons for Closing Source
      - Section 4.7. Use-Value Funding Models
      - Section 4.8. Why Sale Value is Problematic
      - Section 4.9. Indirect Sale-Value Models
      - Section 4.10. When to be Open, When to be Closed
      - Section 4.11. Open Source as a Strategic Weapon
      - Section 4.12. Open Source and Strategic Business Risk
      - Section 4.13. The Business Ecology of Open Source
      - Section 4.14. Coping with Success
      - Section 4.15. Open R&D and the Reinvention of Patronage
      - Section 4.16. Getting There From Here
      - Section 4.17. Conclusion: Life after the Revolution
      - Section 4.18. Afterword: Why Closing a Drivers Loses Its Vendor Money
    - Chapter 5. Revenge of the Hackers
      - Section 5.1. Revenge of the Hackers
      - Section 5.2. Beyond Brooks's Law
      - Section 5.3. Memes and Mythmaking
      - Section 5.4. The Road to Mountain View
      - Section 5.5. The Origins of Open Source
      - Section 5.6. The Accidental Revolutionary
      - Section 5.7. Phases of the Campaign
      - Section 5.8. The Facts on the Ground
      - Section 5.9. Into the Future
    - Afterword: Beyond Software?
    - Appendix A. How to Become a Hacker
      - Section A.1. Why This Document?
      - Section A.2. What Is a Hacker?
      - Section A.3. The Hacker Attitude
      - Section A.4. Basic Hacking Skills
      - Section A.5. Status in the Hacker Culture
      - Section A.6. The Hacker/Nerd Connection
      - Section A.7. Points For Style
      - Section A.8. Other Resources
      - Section A.9. Frequently Asked Questions
    - Appendix B. Statistical Trends in the Fetchmail Project's Growth
    - Appendix C. Notes, Bibliography, and Acknowledgements
      - Section C.1. A Brief History of Hackerdom
      - Section C.2. The Cathedral and the Bazaar
      - Section C.3. Homesteading the Noosphere
      - Section C.4. The Magic Cauldron
      - Section C.5. For Further Reading:
  - Mind Hacks
    - Chapter 1. Inside the Brain
      - Section 1.1. Hacks 1-12
      - Hack 1. Find Out How the Brain Works Without Looking Inside
      - Hack 2. Electroencephalogram: Getting the Big Picture with EEGs
      - Hack 3. Positron Emission Tomography: Measuring Activity Indirectly with PET
      - Hack 4. Functional Magnetic Resonance Imaging: The State of the Art
        Hack 5. Transcranial Magnetic Stimulation: Turn On and Off Bits of the Brain
      - Hack 6. Neuropsychology, the 10% Myth, and Why You Use All of Your Brain
        Hack 7. Get Acquainted with the Central Nervous System
      - Hack 8. Tour the Cortex and the Four Lobes
      - Hack 9. The Neuron
      - Hack 10. Detect the Effect of Cognitive Function on Cerebral Blood Flow
      - Hack 11. Why People Don't Work Like Elevator Buttons
        Hack 12. Build Your Own Sensory Homunculus
    - Chapter 2. Seeing
      - Section 2.1. Hacks 13-33
      - Hack 13. Understand Visual Processing
      - Hack 14. See the Limits of Your Vision
        Hack 15. To See, Act
        Hack 16. Map Your Blind Spot
        Hack 17. Glimpse the Gaps in Your Vision
      - Hack 18. When Time Stands Still
      - Hack 19. Release Eye Fixations for Faster Reactions
      - Hack 20. Fool Yourself into Seeing 3D
        Hack 21. Objects Move, Lighting Shouldn't
        Hack 22. Depth Matters
      - Hack 23. See How Brightness Differs from Luminance: The Checker Shadow Illusion
        Hack 24. Create Illusionary Depth with Sunglasses
        Hack 25. See Movement When All Is Still
        Hack 26. Get Adjusted
        Hack 27. Show Motion Without Anything Moving
      - Hack 28. Motion Extrapolation: The "Flash-Lag Effect"
      - Hack 29. Turn Gliding Blocks into Stepping Feet
      - Hack 30. Understand the Rotating Snakes Illusion
      - Hack 31. Minimize Imaginary Distances
        Hack 32. Explore Your Defense Hardware
      - Hack 33. Neural Noise Isnt a Bug; Its a Feature
    - Chapter 3. Attention
      - Section 3.1. Hacks 34-43
      - Hack 34. Detail and the Limits of Attention
        Hack 35. Count Faster with Subitizing
      - Hack 36. Feel the Presence and Loss of Attention
        Hack 37. Grab Attention
      - Hack 38. Don't Look Back!
      - Hack 39. Avoid Holes in Attention
      - Hack 40. Blind to Change
      - Hack 41. Make Things Invisible Simply by Concentrating (on Something Else)
        Hack 42. The Brain Punishes Features that Cry Wolf
        Hack 43. Improve Visual Attention Through Video Games
    - Chapter 4. Hearing and Language
      - Section 4.1. Hacks 44-52
      - Hack 44. Detect Timing with Your Ears
        Hack 45. Detect Sound Direction
        Hack 46. Discover Pitch
        Hack 47. Keep Your Balance
      - Hack 48. Detect Sounds on the Margins of Certainty
      - Hack 49. Speech Is Broadband Input to Your Head
      - Hack 50. Give Big-Sounding Words to Big Concepts
        Hack 51. Stop Memory-Buffer Overrun While Reading
        Hack 52. Robust Processing Using Parallelism
    - Chapter 5. Integrating
      - Section 5.1. Hacks 53-61
      - Hack 53. Put Timing Information into Sound and Location Information into Light
        Hack 54. Don't Divide Attention Across Locations
        Hack 55. Confuse Color Identification with Mixed Signals
      - Hack 56. Don't Go There
        Hack 57. Combine Modalities to Increase Intensity
        Hack 58. Watch Yourself to Feel More
        Hack 59. Hear with Your Eyes: The McGurk Effect
        Hack 60. Pay Attention to Thrown Voices
      - Hack 61. Talk to Yourself
    - Chapter 6. Moving
      - Section 6.1. Hacks 62-69
      - Hack 62. The Broken Escalator Phenomenon: When Autopilot Takes Over
      - Hack 63. Keep Hold of Yourself
      - Hack 64. Mold Your Body Schema
      - Hack 65. Why Can't You Tickle Yourself?
      - Hack 66. Trick Half Your Mind
      - Hack 67. Objects Ask to Be Used
        Hack 68. Test Your Handedness
      - Hack 69. Use Your Right Brain—and Your Left, Too
    - Chapter 7. Reasoning
      - Section 7.1. Hacks 70-74
      - Hack 70. Use Numbers Carefully
        Hack 71. Think About Frequencies Rather than Probabilities
      - Hack 72. Detect Cheaters
        Hack 73. Fool Others into Feeling Better
      - Hack 74. Maintain the Status Quo
    - Chapter 8. Togetherness
      - Section 8.1. Hacks 75-80
      - Hack 75. Grasp the Gestalt
        Hack 76. To Be Noticed, Synchronize in Time
      - Hack 77. See a Person in Moving Lights
      - Hack 78. Make Things Come Alive
      - Hack 79. Make Events Understandable as Cause and Effect
      - Hack 80. Act Without Knowing It
    - Chapter 9. Remembering
      - Section 9.1. Hacks 81-92
      - Hack 81. Bring Stuff to the Front of Your Mind
      - Hack 82. Subliminal Messages Are Weak and Simple
      - Hack 83. Fake Familiarity
        Hack 84. Keep Your Sources Straight (if You Can)
        Hack 85. Create False Memories
        Hack 86. Change Context to Build Robust Memories
      - Hack 87. Boost Memory Using Context
      - Hack 88. Think Yourself Strong
      - Hack 89. Navigate Your Way Through Memory
        Hack 90. Have an Out-of-Body Experience
        Hack 91. Enter the Twilight Zone: The Hypnagogic State
      - Hack 92. Make the Caffeine Habit Taste Good
    - Chapter 10. Other People
      - Section 10.1. Hacks 93-100
        Hack 93. Understand What Makes Faces Special
        Hack 94. Signal Emotion
      - Hack 95. Make Yourself Happy
        Hack 96. Reminisce Hot and Cold
        Hack 97. Look Where I'm Looking
        Hack 98. Monkey See, Monkey Do
        Hack 99. Spread a Bad Mood Around
      - Hack 100. You Are What You Think