Solid Code · Optimizing the Software Development Life Cycle by Marshall, Donis -- Read -- Imperial Library of Trantor

Index

Solid Code: Optimizing the Software Development Life Cycle

SPECIAL OFFER: Upgrade this ebook with O’Reilly Recommendations for Solid Code Foreword Acknowledgements Introduction

Who Is This Book For? Organization of This Book System Requirements

The Companion Web Site Find Additional Content Online Support for This Book

1. Code Quality in an Agile World

Traditional Methods of Software Development Agile Methods of Software Development

Scrum eXtreme Programming Test-Driven Development

Moving Quality Upstream Inside Microsoft: Windows Live Hotmail Engineering

Engineering Principles

Focus on quality of service, performance, and security Leverage iterative development Ensure predictable and repeatable processes Use common tools, processes, and terminology

Key Success Factors

Delivering testable units Running daily builds Running automated BVTs with daily builds Ship to a "dogfood" environment early and often

Tactics for Writing Solid Code

Focus on Design

Class design and prototyping Metaprogramming Performance Scalability Security

Defend and Debug

Memory management Defensive programming techniques Debugging

Analyze and Test

Code analysis, coverage, and testing

Improve Processes and Attitudes

Improving engineering processes Attitude is everything

Summary Key Points

2. Class Design and Prototyping

Collaboration in Visual Studio Think First, Code Later Software Modeling

Unified Modeling Language

Visio Example

Prototyping

Tracing Visual Studio Class Designer Create a Class Diagram Prototyping with the Class Designer

Automating Enter and Exit Methods

Prototyping Example

Summary Key Points

3. Metaprogramming

What Is Metadata? Metadata in Managed Applications

Application Configuration Files

Configuration Settings Basics Application Configuration Storage Application Configuration Example Database Connection String Configurations Custom Configurations Custom Configuration Section Example Application Configuration in Practice

Metadata in Your Applications

Store application configurations in metadata Store application details in metadata Drive application behavior with metadata

Inside Microsoft: Configuration Management in Windows Live Spaces

Gaining Flexibility with Metaprogramming

All features are configuration driven whenever possible Configuration updates are managed dynamically

Summary Key Points

4. Performance Is a Feature

Common Performance Challenges

Network Latency

Network reliability is poor in certain regions Average round-trip time is high Packet loss is high

Payload Size and Network Round Trips

Compression is not enabled Using multiple small static image files

Limited TCP Connections Poorly Optimized Code

Overuse of redirects Excessive DNS lookups Poorly organized JavaScript and CSS

Analyzing Application Performance

Fiddler Network Monitor Visual Round Trip Analyzer HTTPWatch Analyzing the Performance of Live Search

Tactics for Improving Web Application Performance

Reduce Payload Size

Reduce total bytes by using HTTP compression Minify JavaScript and CSS Re-palletize images

Cache Effectively

Set expiration dates

Optimize Network Traffic

Increase parallel TCP ports Enable Keep-Alives Reduce DNS lookups Avoid redirects Leverage a Content Delivery Network Incorporate CSS Sprites

Organize and Write Code for Better Performance

Make JavaScript and CSS files external Ensure CSS are in the top of the page Place JavaScript at the bottom of the page

Incorporating Performance Best Practices

Establish a Performance Excellence Program

Establish usage scenarios and priorities Analyze competition Set performance goals Implement best practices Measure and test

Inside Microsoft: Tackling Live Search Performance

Web Performance Principles

Set performance budgets for key scenarios Continuously analyze and test application performance Experiment and understand user behavior Understand usage patterns and optimize performance accordingly

Key Success Factors

Understand end-user perceived performance Incorporating performance test tools Learn and live the best practices

Summary Key Points

5. Designing for Scale

Understanding Application Scalability

Approaches to Scalability

Scaling Up Scaling Out

Database Scalability

Tactics for Scaling Web Applications

Choose Scalable Application Designs

Design simple application architectures Design to scale out Partition data effectively

Design Application Infrastructure to Scale

Load balance with hardware Choose the appropriate hardware Use common cluster configurations

Defend Against Application Failure

Ensure that the application is fault tolerant Build redundancy into the application Insulate against dependency failures

Ensure Manageability and Maintainability

Instrument the application code Actively monitor the application Establish key live site metrics and goals Plan for growth and failures

Inside Microsoft: Managing the Windows Live Messenger Service Infrastructure

Engineering Principles

Design to scale out Design every aspect of the application to fail gracefully Automate key manageability tasks Continuously evaluate and plan infrastructure capacity Plan to recover from outages

Summary Key Points

6. Security Design and Implementation

Common Application Security Threats Principles for Designing Secure Applications

Security Design Principles

Establish a Security Process Incorporate Defense-in-Depth Apply the SD3+C Strategy for Secure Applications

SD3+C Strategy and Practices for Secure Applications

Secure by Design

Implement Threat Modeling and Risk Mitigation Tactics Apply Best Practices to Application Design

Apply .NET authentication and authorization mechanisms Encrypt sensitive data Assume external applications and code is insecure Design to fail, and fail securely Handle errors and exceptions securely Implement least privilege Implement privilege separation Sanitize input Validate security coding best practices with FxCop Incorporate security-focused code reviews

Secure by Default

Install only necessary components by default Configure restrictive permissions by default

Secure in Deployment and Communication

Establish a support and bug remediation process Provide setup and configuration guidance to users Adhere to compliance requirements Involve users in the security dialog Establish a security response and communication plan

Understanding .NET Framework Security Principles

Runtime Security Policy Code Access Security Applying Runtime Security Policy

Additional Security Best Practices

Conduct security-focused testing Incorporate penetration testing Review application security before release Add protective infrastructure components

Summary Key Points

7. Managed Memory Model

Managed Heap Garbage Collection

Managed Wrappers for Native Objects GC Class Large Object Heap

Finalization

Non-Deterministic Garbage Collection Disposable Objects Dispose Pattern Weak References

Pinning Tips for the Managed Heap CLR Profiler

CLR Profiler Walkthrough

Summary Key Points

8. Defensive Programming

Defensive Programming and C# Warnings Code Review Software Testing

Test-Driven Development Code Coverage Self-Documenting Code Naming Conventions Pseudo Code Comments

Documentation Comments

Defensive Programming with Classes

Modifiers Interfaces

Defensive Programming Without Examples

Defensive Programming with Examples

Design Patterns Summary Key Points

9. Debugging

Overflow Bug Pentium FDIV Bug Symbols

Symbol Server Source Servers

Preemptive Debugging Proactive Debugging

Managed Debugging Assistants

Visual Studio Environment variable Registry

MDA Example Code Analysis Performance Monitoring

Performance Monitor example

Debugging Debugging Tools

Visual Studio

Production environment

.NET Framework Tools

ILDASM Reflector Son of Strike

Debugging Tools for Windows CLR Profiler Sysinternals

Tracing

Web Application Tracing

Page level tracing Tracing in the web.config file

Exception Handling

Production Debugging

ADPlus

ADPlus Configuration File ADPlus and Web Applications

Summary Key Points

10. Code Analysis

Invest in the Test Process

Define a Test Rhythm Establish Test Work Item Tracking

Incorporate Automated Code Analysis

Use Static Code Analysis Tools Write Application Test Code

Anatomy of a Unit Test

Testing with Visual Studio

Use Metrics to Understand Quality

Measuring Complexity and Maintainability of Code Using Perspectives to Understand Quality

Inside Microsoft: Managing Quality for the Microsoft.com Web Analytics Platform

The Importance of Code Quality The Test Investment Managing Quality

Summary Key Points

11. Improving Engineering Processes

Tactics for Engineering Process Improvement

Establish a Quality-Focused Project Rhythm Implement Source Control and Check-in Processes

Managing Source Control Establishing Check-in Procedures and Criteria

Feature development Unit test verification Unit verification Feature check-in

Release and Test Code Daily

Feature development Build Deploy Verification testing

Automate Daily Builds

NAnt MSBuild Team Foundation Build

Using MSBuild

Project file Items Tasks Properties

Create and Enforce Quality Criteria

Security Performance Scalability

Summary Key Points

12. Attitude Is Everything

Passion Linear versus Iterative Sales Are Good

Features

Flexibility Solve Real Problems You Are Responsible Port Code as New Code Refactoring Priorities Be Realistic Paradigm Shift Expand Your Perspective

A. Agile Development Resources B. Web Performance Resources About the Authors

Donis Marshall John Bruno

Index SPECIAL OFFER: Upgrade this ebook with O’Reilly

← Prev
Back
Next →

← Prev
Back
Next →