Software Development Design and Coding With Patterns Debugging Unit Testing and Refactoring 2nd Edition by John Dooley ISBN 148423152X 978-1484231524

Software Development, Design and Coding: With Patterns, Debugging, Unit Testing, and Refactoring, 2nd Edition by John Dooley- Ebook PDF Instant Download/Delivery: 148423152X , 978-1484231524
Full download Software Development, Design and Coding: With Patterns, Debugging, Unit Testing, and Refactoring, 2nd edition after payment

Product details:

ISBN 10: 148423152X
ISBN 13: 978-1484231524
Author:  John Dooley

 Learn the principles of good software design, and how to turn those principles into great code. This book introduces you to software engineering ― from the application of engineering principles to the development of software. You’ll see how to run a software development project, examine the different phases of a project, and learn how to design and implement programs that solve specific problems. It’s also about code construction ― how to write great programs and make them work. 

Whether you’re new to programming or have written hundreds of applications, in this book you’ll re-examine what you already do, and you’ll investigate ways to improve. Using the Java language, you’ll look deeply into coding standards, debugging, unit testing, modularity, and other characteristics of good programs. With Software Development, Design and Coding, author and professor John Dooley distills his years of teaching and development experience to demonstrate practical techniques for great coding.

Software Development, Design and Coding: With Patterns, Debugging, Unit Testing, and Refactoring, 2nd Table of contents:

Chapter 1: Introduction to Software Development

What We’re Doing

So, How to Develop Software?

Conclusion

References

Chapter 2: Software Process Models

The Four Variables

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

Cruising over the Waterfall

Iterative Models

Evolving the Iterative Model

Risk: The Problem with Plan-Driven Models

Agile Methodologies

Agile Values and Principles

eXtreme Programming (XP)

XP Overview

The Four Basic Activities

Implementing XP: The 12 Practices

Scrum

Scrum Roles

The Sprint

Scrum Artifacts

Sprint Flow

Lean Software Development

Principle 1: Eliminate Waste

Principle 2: Build Quality In

Principle 3: Create Knowledge

Principle 4: Defer Commitment

Principle 5: Deliver Fast

Principle 6: Respect People

Principle 7: Optimize the Whole

Kanban

The Kanban board, WIP, and Flow

Lead Time

Conclusion

References

Chapter 3: Project Management Essentials

Project Planning

Project Organization

Risk Analysis

Resource Requirements

Task Estimates

Project Schedule

Velocity

Project Oversight

Status Reviews and Presentations

Defects

The Retrospective

Conclusion

References

Chapter 4: Requirements

What Types of Requirements Are We Talking About?

User Requirements

Domain Requirements

Non-Functional Requirements

Non-Requirements

Requirements Gathering in a Plan-Driven Project

But I Don’t Like Writing!

Outline of a Functional Specification

Overview

Disclaimer

Author’s Name

Scenarios of Typical Usage

Open Issues

Design and New Feature Ideas

One More Thing

Requirements Gathering in an Agile Project

The Three Cs

Card

Conversation

Confirmation

INVEST in Stories

Independent

Negotiable

Valuable

Estimable

Small

Testable

Product Backlog

SMART Tasks

Specific

Measurable

Achievable

Relevant

Time-Boxed

Sprint/Iteration Backlog

Requirements Digging

Why Requirements Digging Is Hard

Problems of Scope

Problems of Understanding

Problems of Volatility

Non-Technical Problems

Analyzing the Requirements

Conclusion

References

Chapter 5: Software Architecture

General Architectural Patterns

The Main Program—Subroutine Architectural Pattern

Pipe-and-Filter Architecture

An Object-Oriented Architectural Pattern

An MVC Example: Let’s Hunt!

The Problem

Model

View

Controller

The Client-Server Architectural Pattern

The Layered Approach

Conclusion

References

Chapter 6: Design Principles

The Design Process

Desirable Design Characteristics (Things Your Design Should Favor)

Design Heuristics

Designers and Creativity

Conclusion

References

Chapter 7: Structured Design

Structured Programming

Stepwise Refinement

Example of Stepwise Refinement: The Eight-Queens Problem

Proposed Solution 1

Proposed Solution 2

Proposed Solution 3

Refinement 1

Refinement 2

Modular Decomposition

Example: Keyword in Context

Top-Down Decomposition

Modular Decomposition of KWIC

Conclusion

References

Chapter 8: Object-Oriented Overview

An Object-Oriented Analysis and Design Process

Requirements Gathering and Analysis

Design

Implementation and Testing

Release/Maintenance/Evolution

Doing the Process

The Problem Statement

The Feature List

Use Cases

Decompose the Problem

Class Diagrams

Code Anyone?

Conclusion

References

Chapter 9: Object-Oriented Analysis and Design

Analysis

An Analytical Example

Design

Change in the Right Direction

Recognizing Change

Songbirds Forever

A New Requirement

Separating Analysis and Design

Shaping the Design

Abstraction

Conclusion

References

Chapter 10: Object-Oriented Design Principles

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

The Don’t Repeat Yourself Principle

The Single Responsibility Principle

The Liskov Substitution Principle

The Dependency Inversion Principle

The Interface Segregation Principle

The Principle of Least Knowledge

Class Design Guidelines

Conclusion

References

Chapter 11: Design Patterns

Design Patterns and the Gang of Four

The Classic Design Patterns

Patterns We Can Use

Creational Patterns

The Singleton Pattern

The Factory Method Pattern

Structural Patterns

The Adapter Pattern

The Façade Pattern

Behavioral Patterns

The Iterator Pattern

The Observer Pattern

The Strategy Pattern

Conclusion

References

Chapter 12: Parallel Programming

Concurrency vs. Parallelism

Parallel Computers

Flynn’s Taxonomy

Parallel Programming

Scalability

Performance

Obstacles to Performance Improvement

How to Write a Parallel Program

Parallel Programming Models

Designing Parallel Programs

Parallel Design Techniques

Programming Languages and APIs (with examples)

Parallel Language Features

Java Threads

OpenMP9

The Last Word on Parallel Programming

References

Chapter 13: Parallel Design Patterns

Parallel Patterns Overview

Parallel Design Pattern Design Spaces

Finding Concurrency

Algorithm Structure

Supporting Structures

Implementation Mechanisms

A List of Parallel Patterns

Embarrassingly Parallel

Master/Worker

Map and Reduce

MapReduce

Divide & Conquer

Fork/Join

A Last Word on Parallel Design Patterns

References

Chapter 14: Code Construction

A Coding Example

Functions and Methods and Size

Formatting, Layout, and Style

General Layout Issues and Techniques6

White Space

Block and Statement Style Guidelines

Declaration Style Guidelines

Commenting Style Guidelines

Identifier Naming Conventions

Refactoring

When to Refactor

Types of Refactoring

Defensive Programming

Assertions Are Helpful

Exceptions

Error Handling

Exceptions in Java

The Last Word on Coding

References

Chapter 15: Debugging

What Is an Error, Anyway?

What Not To Do

An Approach to Debugging

Reproduce the Problem Reliably

Find the Source of the Error

Debugging Tools

Gdb

Eclipse

XCode

Fix the Error (Just That One)!

Test the Fix

Look for More Errors

Source Code Control

The Collision Problem

Using Lock-Modify-Unlock

Using Copy-Modify-Merge

Source Code Control Systems

Subversion

Git and GitHub

Mercurial

One Last Thought on Coding and Debugging: Pair Programming

Conclusion

References

Chapter 16: Unit Testing

The Problem with Testing

That Testing Mindset

When to Test?

Testing in an Agile Development Environment

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

Chapter 17: Code Reviews and Inspections

Walkthroughs, Reviews, and Inspections

Walkthroughs

Code Reviews

Code Inspections

Inspection Roles

Inspection Phases and Procedures

Planning

The Overview Meeting

Preparation

The Inspection Meeting

Inspection Report

Rework and Follow-up

Reviews in Agile Projects

How to Do an Agile Peer Code Review

Summary of Review Methodologies

Defect Tracking Systems

Defect Tracking in Agile Projects

Conclusion

References

Chapter 18: Ethics and Professional Practice

Introduction to Ethics

Ethical Theory

Deontological Theories

Consequentialism (Teleological Theories)

Ethical Drivers

Legal Drivers

Professional Drivers

Preamble to the ACM/IEEE-CS Software Engineering Code of Ethics

Ethical Discussion and Decision Making

Identifying and Describing the Problem

Analyzing the Problem

People also search for Software Development, Design and Coding: With Patterns, Debugging, Unit Testing, and Refactoring, 2nd :

کتاب software development design and coding

دانلود کتاب software development design and coding

software development design and coding pdf

software development design and coding 3rd edition pdf

software development design and coding book

Tags: John Dooley, Software Development, With Patterns