You are previewing Practical Development Environments.
O'Reilly logo
Practical Development Environments

Book Description

This book doesn't tell you how to write faster code, or how to write code with fewer memory leaks, or even how to debug code at all. What it does tell you is how to build your product in better ways, how to keep track of the code that you write, and how to track the bugs in your code. Plus some more things you'll wish you had known before starting a project.

Practical Development Environments is a guide, a collection of advice about real development environments for small to medium-sized projects and groups. Each of the chapters considers a different kind of tool - tools for tracking versions of files, build tools, testing tools, bug-tracking tools, tools for creating documentation, and tools for creating packaged releases. Each chapter discusses what you should look for in that kind of tool and what to avoid, and also describes some good ideas, bad ideas, and annoying experiences for each area. Specific instances of each type of tool are described in enough detail so that you can decide which ones you want to investigate further.

Developers want to write code, not maintain makefiles. Writers want to write content instead of manage templates. IT provides machines, but doesn't have time to maintain all the different tools. Managers want the product to move smoothly from development to release, and are interested in tools to help this happen more often. Whether as a full-time position or just because they are helpful, all projects have toolsmiths: making choices about tools, installing them, and then maintaining the tools that everyone else depends upon. This book is especially for everyone who ends up being a toolsmith for his or her group.

Table of Contents

  1. Practical Development Environments
    1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
    2. Preface
      1. What This Book Is About
      2. What This Book Is Not About
      3. Who Should Read This Book
      4. What's Inside
      5. Style Conventions
      6. Using Code Examples
      7. Safari Enabled
      8. Comments and Questions
      9. Acknowledgments
    3. 1. Introduction
      1. 1.1. Developing Software Products
      2. 1.2. Open and Closed Software Development
      3. 1.3. Dirty Secrets of Software Projects
      4. 1.4. What Does "Practical" Mean?
      5. 1.5. A Personal Tools Quiz
    4. 2. Project Basics
      1. 2.1. The Parts of a Project
      2. 2.2. Software Configuration Management
      3. 2.3. Building Software
      4. 2.4. Testing Software
      5. 2.5. Tracking Bugs
      6. 2.6. Writing Documentation
      7. 2.7. Releasing Products
      8. 2.8. Maintenance
      9. 2.9. Recommended Tools
        1. 2.9.1. Modern Environments
        2. 2.9.2. Classic Environments
        3. 2.9.3. Future Environments
    5. 3. Project Concepts
      1. 3.1. Preconstructed Development Environments
        1. 3.1.1. SourceForge
        2. 3.1.2. GForge
        3. 3.1.3. CollabNet
        4. 3.1.4. Savane
        5. 3.1.5. BerliOS
        6. 3.1.6. Improving PDEs
      2. 3.2. Why Integration Is Helpful
      3. 3.3. Why Automation Is Vital
      4. 3.4. Automation Environments
        1. 3.4.1. Shell Scripts and Batch Files
        2. 3.4.2. Tinderbox
        3. 3.4.3. Anthill
        4. 3.4.4. CruiseControl
      5. 3.5. Labeling Builds
      6. 3.6. Naming Projects and Machines
        1. 3.6.1. Choosing Project Names
        2. 3.6.2. Choosing Machine Names
      7. 3.7. Choosing New Tools
        1. 3.7.1. Steps When Changing Tools
      8. 3.8. Internationalization and Localization
      9. 3.9. Authentication, Authorization, and Accounting
    6. 4. Software Configuration Management
      1. 4.1. Why Do I Need SCM?
      2. 4.2. What SCM Is and Is Not
      3. 4.3. Drawbacks of SCM
      4. 4.4. A Typical Day's Work with SCM
      5. 4.5. SCM Annoyances
        1. 4.5.1. Branches and Tags
        2. 4.5.2. When to Branch? When to Tag?
        3. 4.5.3. Naming Branches and Tags
        4. 4.5.4. Merge Madness
        5. 4.5.5. Security
        6. 4.5.6. Access Wars
        7. 4.5.7. Filenames to Avoid
        8. 4.5.8. Backups and SCM
          1. 4.5.8.1. Backing up CVS
      6. 4.6. SCM Tools
        1. 4.6.1. CVS
          1. 4.6.1.1. Making your life with CVS easier
        2. 4.6.2. Subversion
        3. 4.6.3. Arch
        4. 4.6.4. Perforce
        5. 4.6.5. BitKeeper
        6. 4.6.6. ClearCase
        7. 4.6.7. Visual SourceSafe
      7. 4.7. Comparison of SCM Tools
      8. 4.8. Wider Uses of SCM
      9. 4.9. Checklist
    7. 5. Building Software
      1. 5.1. How Software Gets Built
        1. 5.1.1. The Different Stages of a Build
        2. 5.1.2. A Typical Build File
      2. 5.2. Build States: Virgin, Up-to-date, Changed, Interrupted, Clean
        1. 5.2.1. Good Builds, Bad Builds
        2. 5.2.2. Build States and Different Targets
        3. 5.2.3. Build States in Practice
      3. 5.3. Build Dependencies
        1. 5.3.1. When Build Dependencies Go Wrong
        2. 5.3.2. How Build Dependencies Change
      4. 5.4. Common Build Problems
        1. 5.4.1. Slow Builds
      5. 5.5. Build Tools
        1. 5.5.1. Shell Scripts and Batch Files
        2. 5.5.2. make
        3. 5.5.3. GNU Autotools
          1. 5.5.3.1. Autoconf
          2. 5.5.3.2. Automake
          3. 5.5.3.3. Libtool
          4. 5.5.3.4. An Autotools "Hello World" program
          5. 5.5.3.5. Debugging GNU Autotools installs
          6. 5.5.3.6. More Autotools
        4. 5.5.4. Ant
        5. 5.5.5. Jam
        6. 5.5.6. SCons
        7. 5.5.7. Custom Build Tools
      6. 5.6. Comparison of Build Tools
      7. 5.7. Changing Your Build Tool
      8. 5.8. Checklist
    8. 6. Testing Software
      1. 6.1. Different Kinds of Tests
        1. 6.1.1. Unit Tests
        2. 6.1.2. System Tests
        3. 6.1.3. Customer Tests
        4. 6.1.4. Other Tests
      2. 6.2. Why Automate Your Tests?
      3. 6.3. Evaluating Test Environments
        1. 6.3.1. Preparing to Test
        2. 6.3.2. Running the Tests
        3. 6.3.3. After the Tests
        4. 6.3.4. Good Test Reports
      4. 6.4. Test Environments
        1. 6.4.1. Shell Scripts and Batch Files
        2. 6.4.2. xUnit
        3. 6.4.3. DejaGnu
        4. 6.4.4. SilkTest
      5. 6.5. Types of Test Tools
        1. 6.5.1. Memory Analyzers
        2. 6.5.2. Coverage Tools
        3. 6.5.3. Performance Tools
        4. 6.5.4. Static Code Analyzers
      6. 6.6. The Difficult Parts of Testing
        1. 6.6.1. Faults of Omission
        2. 6.6.2. Capturing Output
        3. 6.6.3. Using Multiple Machines
          1. 6.6.3.1. Sending commands
          2. 6.6.3.2. Starting the tests
          3. 6.6.3.3. Collecting the data
        4. 6.6.4. Only a Developer Can Do That!
        5. 6.6.5. Accessibility Testing
      7. 6.7. Checklist
    9. 7. Tracking Bugs
      1. 7.1. Tool Requirements
      2. 7.2. Bug Tracking Tools
        1. 7.2.1. Spreadsheets
        2. 7.2.2. Different Server Technologies
        3. 7.2.3. Bugzilla
        4. 7.2.4. GNATS
        5. 7.2.5. FogBugz
        6. 7.2.6. JIRA
        7. 7.2.7. TestTrack
        8. 7.2.8. Custom Bug Tracking Tools
      3. 7.3. Bug Tracking Annoyances
        1. 7.3.1. Multiplying Products
        2. 7.3.2. Cleaning Up
        3. 7.3.3. One Bug, Multiple Releases
        4. 7.3.4. Severity Inflation
        5. 7.3.5. Identifying the Right Area
        6. 7.3.6. Customizing the Bug Tracking System
        7. 7.3.7. Overloading Fields
        8. 7.3.8. Bug History
        9. 7.3.9. Bug Statistics
        10. 7.3.10. Writing an Effective Bug Report
      4. 7.4. Integrating with SCM Tools
      5. 7.5. Checklist
    10. 8. Documentation Environments
      1. 8.1. Technical Documentation
        1. 8.1.1. Is Documentation a Separate Product?
        2. 8.1.2. Writing Documentation Is Like Writing Code
      2. 8.2. Documents and SCM
      3. 8.3. File Formats for Documentation
        1. 8.3.1. File Formats for Customers
          1. 8.3.1.1. HTML
          2. 8.3.1.2. PostScript
          3. 8.3.1.3. PDF
      4. 8.4. Documentation Environments
        1. 8.4.1. Raw Text
        2. 8.4.2. FrameMaker
        3. 8.4.3. XML: DocBook and OpenOffice
          1. 8.4.3.1. DocBook
          2. 8.4.3.2. The tools used to write this book
          3. 8.4.3.3. OpenOffice
        4. 8.4.4. Microsoft Word
      5. 8.5. More File Formats
      6. 8.6. Automated Production of Documentation
      7. 8.7. Bad Ideas for Documentation
        1. 8.7.1. Releasing the Documentation Separately
        2. 8.7.2. Ransom-Note Cut and Paste
        3. 8.7.3. Old Versions That Never Die
        4. 8.7.4. Funky Filenames
        5. 8.7.5. Screenshots
      8. 8.8. Internal Project Documentation
      9. 8.9. Checklist
    11. 9. Releasing Products
      1. 9.1. Overview
      2. 9.2. Before the Release
        1. 9.2.1. System Requirements
        2. 9.2.2. Build Numbers
        3. 9.2.3. Release Numbering
        4. 9.2.4. Release Information
        5. 9.2.5. Upgrading
        6. 9.2.6. Legal Licenses
        7. 9.2.7. License Keys
        8. 9.2.8. Securing Your Releases
        9. 9.2.9. Quick Fixes and Engineering Specials
      3. 9.3. Creating the Release
        1. 9.3.1. Automated Releases
        2. 9.3.2. Automating Release Information
        3. 9.3.3. Developers as Customers
      4. 9.4. Packaging Formats
        1. 9.4.1. Unix
        2. 9.4.2. Windows
      5. 9.5. Installation Tools
        1. 9.5.1. Requirements
          1. 9.5.1.1. Tools
          2. 9.5.1.2. Installers
        2. 9.5.2. Unix
          1. 9.5.2.1. Source code and binaries
          2. 9.5.2.2. RPM package manager
          3. 9.5.2.3. apt
          4. 9.5.2.4. CPAN
        3. 9.5.3. Windows
          1. 9.5.3.1. Windows Installer
          2. 9.5.3.2. InstallShield
          3. 9.5.3.3. InstallAnywhere
          4. 9.5.3.4. Wise for Windows
          5. 9.5.3.5. InnoSetup
          6. 9.5.3.6. NSIS
      6. 9.6. Installation Irritations—Ship Happens!
      7. 9.7. After the Release
      8. 9.8. Checklist
    12. 10. Maintenance
      1. 10.1. Maintaining an Environment
        1. 10.1.1. Migrating Your Data
      2. 10.2. What Is Product Maintenance?
        1. 10.2.1. Developing for Easier Maintenance
      3. 10.3. Product Maintenance Tasks
        1. 10.3.1. Understanding Code
        2. 10.3.2. Reproducing a Build
        3. 10.3.3. Handling Product Name Changes
        4. 10.3.4. Handling Company Name Changes
        5. 10.3.5. Handling Copyright Date Changes
      4. 10.4. Product Maintenance and Development Environments
        1. 10.4.1. SCM
        2. 10.4.2. Building
        3. 10.4.3. Testing
        4. 10.4.4. Bug Tracking
        5. 10.4.5. Documentation
        6. 10.4.6. People and Politics
      5. 10.5. Cleaning Up Your Environment
      6. 10.6. Checklist
    13. 11. Project Communication
      1. 11.1. Tools for Communication
      2. 11.2. A Project Web Site
        1. 11.2.1. Access Control
      3. 11.3. Different Areas for the Project Web Site
        1. 11.3.1. Home Page
        2. 11.3.2. Getting Started
        3. 11.3.3. Specifications
        4. 11.3.4. SCM
        5. 11.3.5. Building
        6. 11.3.6. Testing
        7. 11.3.7. Bug Tracking
        8. 11.3.8. Documentation
        9. 11.3.9. Releases
        10. 11.3.10. Maintenance
        11. 11.3.11. Support
        12. 11.3.12. Project Management
        13. 11.3.13. About the Web Site
      4. 11.4. Creating the Web Site
        1. 11.4.1. Static Web Pages
        2. 11.4.2. Dynamic Web Pages
        3. 11.4.3. Indexing and Searching
      5. 11.5. Avoiding Content Rot
    14. 12. Politics and People
      1. 12.1. The Role of the Toolsmith
        1. 12.1.1. How to Choose a Toolsmith
      2. 12.2. When Good Projects Go Bad
      3. 12.3. Awkward People
      4. 12.4. Twisted Communications
      5. 12.5. Commit Rights
      6. 12.6. Automation Discipline
      7. 12.7. What Do Developers Really Want?
      8. 12.8. An Upbeat Ending
    15. A. How Tools Scale
      1. A.1. Scaling of Compilers
        1. A.1.1. How the Compiler gcc Scales
          1. A.1.1.1. Number of source files
          2. A.1.1.2. Number of functions
          3. A.1.1.3. Number of libraries
          4. A.1.1.4. Number of included files
      2. A.2. Scaling of Build Tools
        1. A.2.1. Comparing Recursive and Included make
    16. B. Resources
      1. B.1. Online
        1. B.1.1. Content
        2. B.1.2. Discussions
        3. B.1.3. Directories
      2. B.2. Magazines
      3. B.3. Books
        1. B.3.1. Automation and General Tools
        2. B.3.2. Software Configuration Management
        3. B.3.3. Building Software
        4. B.3.4. Testing Software
        5. B.3.5. Tracking Bugs
        6. B.3.6. Documentation Environments
        7. B.3.7. Releasing Products
        8. B.3.8. Maintenance
        9. B.3.9. Politics and People
        10. B.3.10. Developing Software
        11. B.3.11. General Design
      4. B.4. Conferences
      5. B.5. University and College Courses
    17. Index
    18. About the Author
    19. Colophon
    20. SPECIAL OFFER: Upgrade this ebook with O’Reilly