About The Author

1. Other Leanpub Books by Jason Roberts
2. Pluralsight Courses

Introduction

1. Why Keep Software Soft?
2. Why Read This Book?
3. Part 1: The Code

The SOLID Principles of OO Design

1. The Single Responsibility Principle (SRP)
2. The Open Closed Principle (OCP)
3. The Liskov Substitution Principle (LSP)
4. The Interface Segregation Principle (ISP)
5. Dependency Inversion Principle (DIP)

Other Important Principles

1. Keep It Simple Stupid (KISS)
2. Don’t Repeat Yourself (DRY)
3. You Aren’t Gonna Need It (YAGNI)
4. Cohesion
5. Coupling
6. Law of Demeter (LoD)

Dependency Inversion Revisited

1. Dependency Injection Containers
2. An Example of Dependency Injection with Ninject
3. Other Containers
4. Why Use a Dependency Injection Container?

Some Useful Design Patterns

1. Gateway
2. Decorator
3. Strategy
4. Factory
5. Chain of Responsibility

Readability - Writing Code for Humans

1. Comments
2. Naming Booleans
3. Method Length
4. Remove Unused Code
5. Nesting
6. Naming Variables and Parameters
7. Whitespace
8. Regions
9. Magic Strings and Constants

An Introduction to Architectural Styles

1. Client-Server
2. Layered
3. Message Bus
4. Service Oriented Architecture
5. Onion Architecture
6. Event Sourcing
7. Part 2: Testing

An Introduction to Unit Testing with xUnit.net

1. Qualities of Good Unit Tests
2. Testing Frameworks
3. About xUnit.net
4. Using xUnit.net
5. Data Driven Tests

Test Driven Development

1. Overview
2. Example
3. Practicing TDD
4. Why TDD?

Faking It - Testing Code in Isolation

1. Mock, Stub, Fake, Dummy, Test Double
2. An Example of Faking

Auto Mocking

1. Introducing Auto Mocking
2. More About AutoFixture
3. AutoFixture and xUnit.net Custom Attributes

Introduction to JavaScript Unit Testing

1. Introducing QUnit
2. Creating and Running QUnit Tests in Visual Studio 2012
3. Creating and Running QUnit Tests in HTML

An Introduction to Automated Functional UI Testing for Web Applications

1. Record-Playback Versus Coded Automation
2. An Example of Coded AFUITs Using WatiN
3. The Demo Application
4. Creating the First Tests
5. Refactoring the Tests
6. Some Other Tools

An Introduction to Continuous Integration with TeamCity

1. Build Pipelines
2. Implementing a Build Pipeline in TeamCity
3. Alternative CI/Build Servers

A Holistic View of Testing

1. Types of Testing
2. The Testing Pyramid
3. What and Where to Test
4. Testing Legacy Applications
5. Part 3: People and Process

An Introduction to Agile Software Development

1. Overview
2. Agile Software Development in Practice
3. Overarching Principles

Pair Programming and Code Reviews

1. Formal Code Reviews
2. Pair Programming

Time Management and Motivation

1. Time Management
2. Prioritisation With MoSCoW
3. Prioritisation with Covey Quadrants
4. Maintaining Energy with the Pomodoro Technique
5. Maintaining Motivation with the Power of Three

Technical Debt

1. Examples of Technical Debt
2. Causes of Technical Debt
3. Mindfulness of Creating Technical Debt
4. Recording and Prioritising Technical Debt
5. The Effect of Technical Debt on People and Organisations

Software Craftsmanship, Professionalism, and Personal Development

1. Software Craftsmanship
2. Beyond Craftsmanship - Into Professionalism
3. Personal Development

What Programmers Want and What Your Manager Should Understand

1. What Programmers Want Survey
2. Challenging Work, Creative Solutions, Making a Difference
3. Tools and Environment
4. The Joel Test
5. Appendices

Appendix A: Manifesto for Agile Software Development

Appendix B: Principles behind the Agile Manifesto

Appendix C: Testing Framework Attributes

Appendix D: Design Pattern List

1. Creational Patterns
2. Structural Patterns
3. Behavioural Patterns

Appendix E: Manifesto for Software Craftsmanship