[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Bug in LOAD-PATCHES (and hence LOAD-SYSTEM) affecting using 7.1 and 7.0

We are switching from 7.0 to 7.1 but are doing it cautiously thus only a
few machines are running 7.1.

Some of our 7.0 machines were loading patches when it seemed they shouldn't.
This causes grief because (1) some patches were compiled in 7.1 and the user
gets a message that he should be using 7.1 and (2) some patches were compiled
in 7.0 that get loaded first and so he is not at the right patch level for
any of the systems in SCT:*RELEASES* (which then causes other problems).

The question was why were they loading these patches??  I first suspected
it was their calling LOAD-PATCHES themselves but when that wasn't the case
I had to interrupt it when it tried to load patches.

What happens is that if you call
where FOO is a non-patchable system, that function calls 
(LOAD-PATCHES #<SYSTEM FOO..>).  In LOAD-PATCHES (which must be a critical
piece of code since Symbolics has chosen not to let us see the problems in
it!!), the code calls (SCT:GET-PATCHABLE-SYSTEM-NAMED #<SYSTEM FOO..>)
which returns NIL (as it should).  Then the code decides that since the
arg passed into LOAD-PATCHES didn't result in any patchable systems, the
user obviously meant what he would have meant by saying (LOAD-PATCHES),
ie with no args at all.  Therefore it loads patches for every patchable system.

Since we don't have sources to this critical piece of code, the only option
we have is to tell our users that either every system has to be patchable
(which is crazy) or they have to call LOAD-SYSTEM with the extra keyword arg
of :LOAD-PATCHES NIL.  1I would appreciate having a patch for this.0  Last week,
if you don't mind...

Bug #2 is that the CP command :LOAD SYSTEM doesn't seem to have a way
to do the equivalent of :DONT-SET-VERSION T.  That keyword is used for those
people who don't want to bother with :COMPILE SYSTEM at all and just use
the System concept to define a related set of files.

Wish #3 is that there should be a way to define in a system definition that
the default version is :NEWEST.  

An explanation behind that wish:  We have a research system that is
evolving quite rapidly.  The number of functions changed daily is so
great that it is simply not worth writing daily patch files.  People
will make a change, see how it works, undo that change, make another
change, etc.  When done, they write out and compile the files they
changed (and only those).

This method of a group working on a collection of files predates systems and is
rather natural.   It is a shame that there isn't an easy way to say
that a system should be treated that way.  Currently we have to do a
:LOAD SYSTEM ... :VERSION NEWEST  (Woe be to the person who forgets :VERSION
NEWEST).  I suppose another way to do this is to always call COMPILE-SYSTEM
(the cp command :COMPILE SYSTEM isn't good enough) with some set of args
to update the system directory but not to compile anything (you don't want
to compile a file someone else might have saved in the middle of changing).

(Using the patch system would also require a lot of gcing of patch files and
directories rather than just keeping around the most recent binaries and

The current philosophy of systems seems to work well with mature collections of
code whose incremental change is small compared to the total amount of code.
It doesn't work well for collections of code whose repeated incremental changes
are a significant part of the code.