Software Development Design and Coding 2nd by Dooley 9781484231524 1484231538

Software Development, Design and Coding 2nd by John F. Dooley – Ebook Instant Download/Delivery ISBN: 9781484231524 , 1484231538

Product details:

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

Case Studies

#1 Copying Software

#2 Who’s Computer Is It?

#3 How Much Testing Is Enough?

#4 How Much Should You Tell?

The Last Word on Ethics?

References

The ACM Code of Ethics and Professional Conduct

Preamble

Contents & Guidelines

1. GENERAL MORAL IMPERATIVES

1.1 Contribute to society and human well-being

1.2 Avoid harm to others

1.3 Be honest and trustworthy

1.4 Be fair and take action not to discriminate

1.5 Honor property rights including copyrights and patent

1.6 Give proper credit for intellectual property

1.7 Respect the privacy of others

1.8 Honor confidentiality

2. MORE SPECIFIC PROFESSIONAL RESPONSIBILITIES

2.1 Strive to achieve the highest quality, effectiveness and dignity in both the process and product

2.2 Acquire and maintain professional competence

2.3 Know and respect existing laws pertaining to professional work

2.4 Accept and provide appropriate professional review

2.5 Give comprehensive and thorough evaluations of computer systems and their impacts, including ana

2.6 Honor contracts, agreements, and assigned responsibilities

2.7 Improve public understanding of computing and its consequences

2.8 Access computing and communication resources only when authorized to do so

3. ORGANIZATIONAL LEADERSHIP IMPERATIVES

3.1 Articulate social responsibilities of members of an organizational unit and encourage full accep

3.2 Manage personnel and resources to design and build information systems that enhance the quality

3.3 Acknowledge and support proper and authorized uses of an organization’s computing and communic

3.4 Ensure that users and those who will be affected by a system have their needs clearly articulate

3.5 Articulate and support policies that protect the dignity of users and others affected by a compu

3.6 Create opportunities for members of the organization to learn the principles and limitations of

4. COMPLIANCE WITH THE CODE

4.1 Uphold and promote the principles of this Code

4.2 Treat violations of this code as inconsistent with membership in the ACM

The ACM/IEEE-CS Software Engineering Code of Ethics

PREAMBLE

PRINCIPLES

Chapter 19: Wrapping It all Up

People also search:

what is the difference between coding and software development

bd software development program

difference between coding and software development

c software development

fdm software developer salary