Synopses & Reviews
Now there's a book that gives you some help managing your project's source files. Applying RCS and SCCS is a thorough introduction to the two most popular source control systems under UNIX. The authors of this book take you from basic source control of a single file, through working with multiple releases of a software project, to coordinating teams of developers on a project involving many files and more than one target platform. The authors go well beyond lists of commands and command options: they help you define the problem you're really trying to solve, and then they show you how to solve it. This book also presents TCCS, a representative "front-end" to RCS and SCCS that addresses problems RCS and SCCS can't handle alone, such as managing groups of files, developing for multiple platforms, and linking public and private development areas. If you're a programmer or a software project manager, this book should be required reading.
Synopsis
Applying RCS and SCCS tells you how to manage a complex software development project using RCS and SCCS. The book tells you much more than how to use each command; it's organized in terms of increasingly complex management problems, from simple source management, to managing multiple releases, to coordinating teams of developers on a project involving many files and more than one target platform.Few developers use RCS or SCCS alone; most groups have written their own extensions for working with multiperson, multiplatform, multifile, multirelease projects. Part of this book, therefore, discusses how to design your own tools on top of RCS or SCCS, both covering issues related to "front-ending" in general, and by describing TCCS, one such set of tools (available via FTP). This book also provides an overview of CVS, SPMS, and other project management environments.
Synopsis
Applying RCS and SCCS tells readers how to manage complex software development projects using RCS and SCCS. It covers the main features of RCS and SCCS, and includes an overview of CVS, SPMS, and other source and project management environments. Features quick references for RCS and SCCS, and implements notes for those who need to work with them quickly.
Description
Includes bibliographical references (p. 479-485) and index.
About the Author
Don Bolinger is a software engineer in the Research Institute of the Open Software Foundation, where he works with the Mach microkernel and serverized UNIX systems. He has labored on, in, and under various UNIX-like environments for around 15 years. His first exposure to project control came long ago via an m4-based front-end to make, which demonstrated how easy and useful (not to say necessary) it is to write such extensions under UNIX. Subsequent work on many other tools taught him the value of discipline and a healthy respect for prior art, both of which he hopes this book manages to pass along. Don got his B.A. in English from Yale University, and finds natural languages just as engaging as the programming kind. He enjoys French history, culture, and wine (not necessarily in that order).
Tan Bronson is currently director of software engineering at Hill Arts & Entertain ment, in Guilford, Connnecticut, where he works on providing ticketing to the performing arts and related industries. Tan's been working on or around UNIX systems since his exposure to Version 6 UNIX 15 years ago. On Version 6 UNIX he started writing drivers, and over the years worked his way "up to" applications. His first exposure to source code control was a homebrew system that built software that was cross-compiled on a Vax for a 68010 UNIX box, and ran on the same Vax. It quickly grew to a more "general purpose" collection of tools. Over the years he's tried to take advantage of all the good ideas he's encountered building and controlling projects, and help other people have better control over the software project they need to release and maintain. Tan got his B.S. in electrical engineering from the University of Maine at Orono, and spends his spare time with his family and working on a variety of home construction projects. (Unfortunately, RCS doesn't apply to these!)
Table of Contents
Applying RCS and SCCS
Table of Contents
Preface
Chapter 1. Source and Project Control
The Source File Modification Cycle
Introduction to Source Control
The Goals of Source Control
The Development Process
Introduction to Project Control
The Goals of Project Control
Introduction to TCCS
TCCS in Later Chapters
Chapter 2. The Basics of Source Control
Putting Files Under Source Control
Some Conventions
Source Control Using Archive Files
Chapter 3. Basic Source Control Using RCS
Background
Conventions
Basic RCS Commands
Summary
Chapter 4. Basic Source Control Using SCCS
Background
Conventions
Basic SCCS Commands
Summary
Chapter 5. Extending Source Control to Multiple Releases
Adding Releases to a Development Process
The Structure of Archive Files
Changing Branches in Parallel
Classifying Revision Numbers
Beyond RCS and SCCS: Working with Views
Beyond RCS and SCCS:\& Applying Multiple Branches
Chapter 6. Applying RCS to Multiple Releases
RCS Revision Trees
Operations Between Tree Branches
Chapter 7. Applying SCCS to Multiple Releases
SCCS Revision Trees
Operations Between Tree Branches
Chapter 8. Managing the Mechanics of Releases
Applying Revision Numbers
Marking Revisions
Identifying Revisions
Removing Unneeded Source File Revisions
Chapter 9. Release Mechanics in RCS
Applying Revision Trees: Single-Branch\& Development
More on Revision Characteristics
Specifying Revisions to RCS Commands
Marking Revisions
Outdating Revisions
Identification Keywords
Getting Information on Archive Files
Chapter 10. Release Mechanics in SCCS
Applying Revision Trees: Single-Branch\& Development
Revision and Archive File Characteristics
Determining the Ancestry of a Working File
Virtual Snapshots in SCCS
Outdating Revisions
Identification Keywords
Getting Information on Archive Files
Validating Archive Files
Chapter 11. Extending Source Control to Multiple Developers
Controlling Access to Files
Controlling File Access Under Source Control
Coordinating Multiple Streams\& of Development
Chapter 12. Applying RCS to Multiple Developers
File Protection in RCS
Access Lists in RCS
Controlling Locks
Recording Who's Using a File
Chapter 13. Applying SCCS to Multiple Developers
Installing SCCS as Setuid
Access Lists in SCCS
Controlling Changes to an Archive File
Chapter 14. Creating Front-Ends for RCS or SCCS
Installing and Interfacing to a Front-End
What Front-Ends Are Good For
Applying setuid to Front-Ends
Chapter 15. Going Further with Source Control
Raw RCS/SCCS
Simple Front-Ends
Layering on Top of RCS/SCCS
Independent Products
Chapter 16. Moving from Source Control to Project Control
Roles in the Development Process
Supporting the Developer's Roles
How Projects Support Development Jobs
Project Etiquette
Chapter 17. Contents of a Project
Going Beyond the Sources
The Project as a Whole
The Project Root
The Checkpoint Tree
The Build Tree
The Work Area
Toolsets
Chapter 18. Administering a Project
Defining a Project Root with mkroot
Creating Checkpoints
Controlling Access to Checkpoints
Controlling Checkpoint Population
Defining a Toolset
Naming a Platform Description
Defining a Build Tree
Deleting and Pruning TCCS Trees
Chapter 19. Makefile Support for Projects
The Structured Use of make
Approaches to Building Software
Choosing a make (None Are Perfect)
Creating the Internal make Support for wamake
Guidelines for Makefile Creation
Summary
Chapter 20. Using Work Areas
Extending the Example
Working on a Project: Preliminaries
Using a Work Area--Getting Started
Naming a Work Area
Creating a Source-Only Work Area
Using Work Areas--More Examples
Sharing a Work Area
Adding a Build Tree to Your Work Area
Removing and Cleaning Up Work Areas
Release Engineer\(enOnly Commands
Chapter 21. Extensions for Cross-Development
An Example of Multi-Platform Software
Target-Specific Files
Managing Your Defines
Multiple Target Platforms Under TCCS
Multiple Platform Descriptions\& in a Single Project
Chapter 22. Structuring the Build Process
Where Should make Run?
Dividing the Build into Phases
More on Using install and share
Chapter 23. Existing Layers on RCS and SCCS
sccs--The BSD Front-End
VC--An Emacs Front-End to RCS and SCCS
UBE--UTek Build Environment
SPMS--Software Project Management System
PTOOLS--Using SCCS Modification Requests
Aegis--Development with Constant Testing
CCSLAND--Configuration Control\& System Land
ODE and the btools--Distributed, Nested Build System
CVS--Concurrent Version System
MK--A Configuration Management Concept
Boxes, Links, and Parallel Trees
Summary
Appendix A. RCS Quick Reference
Command-Line Conventions
Key Operations
Appendix B. SCCS Quick Reference
Command-Line Conventions
Key Operations
Appendix C. RCS and SCCS Compared
Revision Storage in Archive Files
Support for Marking Revisions
Support for Archive File Branches
Check-in Validation
Keyword Handling
Command-Line Conventions
Support for Changing Your Mind
Support for Non-UNIX Environments
Appendix D. RCS Details in Depth
Choosing Comment Leader Strings
Using Different RCS Versions
Another Look at How co and ci\& Choose Revisions
Appendix E. SCCS Details in Depth
More on Identification Keywords
More on prs Data Specifiers
Another Look at How get Chooses Revisions
Appendix F. RCS/SCCS Internals
RCS Internals
SCCS Internals
Appendix G. Changes in RCS Version 5.7
New or Changed Features
New or Changed Command Options
Appendix H. References
Index
END