It is possible to use the same build tools and makefiles on both Unix and NT.
The usual mechanism is to write a platform-specific makefile that defines
default rules and basic macro definitions. Using Gnu Make makes the job
easier because its unique features can be brought to bear wherever they're
needed. Similar approaches can be taken with some of the alternatives to
Make, such as Cook and Odin, which are also available on Unix and NT.
As for inter-project references, the traditional approach is to provide
for the developers a pre-built reference build of the stuff that they rely
on but don't write for themselves. Sometimes they build their own, other
times someone builds well-known versions of these reference builds (often
called "baselines") in an area that can't be written by the developers.
Occasionally, shared code is checked out from CVS into a developer's sandbox
and is built there by the developer.
If you opt to break your project up, you must provide a means in which the
developer references shared code from his sandbox. Environment variables
are often used for this, their values imported into Makefile macros to be
used in path computations. (The buildref tools at
http://www.wakawaka.com/source.html can also be useful for this, but they
have not been ported to NT.) Some shops use symbolic links for this purpose,
also.
If you have a budget larger than 0, you might look into ClearCase. It can
simplify some of this stuff, and it has a good tool for importing its
repository from RCS. Its version of Make works the same way on all of its
supported platforms (including NT), and the users' sandboxes can be made to
appear in the same place in the filesystem, regardless of how many sandboxes
there are. ClearCase also supports symbolic links on NT, provided that both
the pointer and its target are in the same repository.
--- Forwarded mail from [EMAIL PROTECTED]
I'm investigating CVS as a possible solution for my organization's config
management woes. So far, I like what I see, but I some questions;
hopefully someone out there can give me some advice.
Our environment is mixed win32/hpux. We are in the same boat as lots of
folks (I think,) where most past development was targeted for unix, but
the low cost of PCs and the desire for Office/Outlook on all desktops is
driving us towards NT (kicking and screaming.) Anyway, we really have two
problems: First, can we have similar build environments in unix and NT?
Second, what tool should we use for software configuration management?
I think we may be able to use GNU make in both environments with lots of
conditionals to define the correct compiler, options, etc. I hope this
will solve problem one.
On the surface, CVS seemed like the solution to problem two. It works on
unix and windows. It uses RCS's file format, so bringing our existing RCS
controlled files into CVS probably won't be hard. The problem I'm really
struggling with is that a lot of our projects include headers and link
from other projects. (The reason for this is we have a fair number of
client-server APIs built. When a program wants to be a client, it
includes from the common and client areas of the appropriate API.)
Currently, all the projects reside on the same NFS volume, so they are
visible to each other. From what I understand of CVS, projects on
networked file systems are bad. Also, when a programmer wants to work on
a project, the project's code is copied to a local filesystem. How can I
set things up so includes from other projects work? I sure don't want to
manually check out several projects just to work on one. Is there a way
to have CVS automatically check out projects (read only) that the work
project depends on? I read a little about vendor branches, but this
approach looks like it would result in a lot of duplicated code in many
of our projects.
--- End of forwarded message from [EMAIL PROTECTED]
