Contents

images About the Author

images About the Technical Reviewer

images Acknowledgments

images Preface

images Chapter 1: Introduction to Software Development

What We're Doing

So, How to Develop Software?

Conclusion

References

images Chapter 2: Process Life Cycle Models

A Model That's not a Model At All: Code and Fix

Cruising over the Waterfall

Backing Up the Waterfall

Loops Are Your Friend

Evolving the Incremental Model

Agile Is as Agile Does

eXtreme Programming (XP)

XP Overview

XP Motivation

The Four Variables

The Four Values

The 15 Principles

The Four Basic Activities

Implementing XP: The 12 Practices

The XP Life Cycle

Scrum, mate

Conclusion

References

images Chapter 3: Project Management Essentials

Project Planning

Project Organization

Risk Analysis

Resource Requirements

Work Breakdown and Task Estimates

Project Schedule

Project Oversight

Status Reviews and Presentations

Defects

The Post-Mortem

Conclusion

References

images Chapter 4: Requirements

What Types of Requirements Are We Talking About Here?

Functional Specification?

But I Don't Like Writing!

That Natural Language Thing

Outline of a Functional Specification

Overview

Disclaimer

Author's Name

Scenarios of Typical Usage

Detailed Screen-By-Screen Specifications

Non-requirements

Open Issues

Design and Feature Ideas

Backlog

One More Thing

Types of Requirements

User Requirements

Domain Requirements

Non-functional Requirements

Non-requirements

Requirements Digging

Why Requirements Digging Is Hard

Analyzing the Requirements

Conclusion

References

images Chapter 5: Software Architecture

General Architectural Patterns

Pipe-and-filter Architecture

An Object-Oriented Architectural Pattern

An MVC Example: Let's Hunt!

The Problem

Model

View

Controller

Model

The Client-Server Architectural Pattern

The Layered Approach

The Main Program: Subroutine Architectural Pattern

Conclusion

References

images Chapter 6: Design Principles

The Design Process

Desirable Design Characteristics (Things Your Design Should Favor)

Design Heuristics

Designers and Creativity

Conclusion

References

images Chapter 7: Structured Design

Structured Programming

Stepwise Refinement

Example of Stepwise Refinement: The Eight-Queens Problem

Modular Decomposition

Example: Keyword in Context: Indexes for You and Me

Top-Down Decomposition

Conclusion

References

Appendix: The Complete Non-Recursive Eight-Queens Program

Chapter 8: Object-Oriented Analysis and Design–An Overview

An Object-Oriented Analysis and Design Process

Doing the Process

The Problem Statement

The Feature List

Use Cases

Decompose the Problem

Class Diagrams

Code Anyone?

Conclusion

References

images Chapter 9: Object-Oriented Analysis and Design

A Play in Several Acts

PRELUDE: In Which We Set the Scene

ACT ONE, Scene 1: In Which We Enquire into Analysis

ACT ONE, Scene 2: In Which We Deign to Design

ACT TWO, Scene 1: Change in the Right Direction

Songbirds Forever

ACT TWO, Scene 2: In Which the Design Will also Change, for the Better

ACT THREE, Scene 1: In Which We Do Design

ACT FOUR, Scene 1: In Which We Philosophize on Abstraction

Conclusion

References

images Chapter 10: Object-Oriented Design Principles

Our List of Fundamental Object-Oriented Design Principles

Encapsulate Things in Your Design That Are Likely to Change

Code to an Interface Rather Than to an Implementation

The Open-Closed Principle (OCP)

Don’t Repeat Yourself Principle (DRY)

The Single Responsibility Principle (SRP)

Liskov Substitution Principle (LSP)

The Dependency Inversion Principle (DIP)

The Interface Segregation Principle (ISP)

The Principle of Least Knowledge (PLK)

Class Design Guidelines for Fun and Enjoyment

Conclusion

References

images Chapter 11: Design Patterns

Design Patterns and the Gang of Four

The Classic Design Patterns

Patterns We Can Use

Creational Patterns

Structural Patterns

Behavioral Patterns

Conclusion

References

images Chapter 12: Code Construction

A coding example

Functions and Methods and Size, Oh My!

Formatting, Layout, and Style

General Layout Issues and Techniques

White Space

Block and Statement Style Guidelines

Declaration Style Guidelines

Commenting Style Guidelines

Identifier Naming Conventions

Defensive Programming

Assertions Can Be Your Friend

Exceptions and Error Handling

Error Handling

Exceptions in Java

The Last Word on Coding

References

images Chapter 13: Debugging

What’s an Error, Anyway?

What Not To Do

An Approach to Debugging

Reproduce the Problem Reliably

Find the Source of the Error

Fix the Error (Just That One)!

Test the Fix

Look for More Errors

Source Code Control

Using Lock-Modify-Unlock

Using Copy-Modify-Merge

One Last Thought on Coding and Debugging – Pair Programming

Conclusion

References

images Chapter 14: Unit Testing

The Problem with Testing

That Testing Mindset

When to Test?

What to Test?

Code Coverage: Test Every Statement

Data Coverage: Bad Data Is Your Friend?

Characteristics of Tests

How to Write a Test

The Story

The Tasks

The Tests

JUnit: A Testing Framework

Testing Is Good

Conclusion

References

images Chapter 15: Walkthroughs, Code Reviews, and Inspections

Walkthroughs, Reviews, and Inspections – Oh My!

Walkthroughs

Code Reviews

Code Inspections

Inspection Roles

Inspection Phases and Procedures

Summary of Review Methodologies

Defect Tracking Systems

Conclusion

References

images Chapter 16: Wrapping It all Up

What Have You Learned?

What to Do Next?

References

images Index

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.17.79.20