|
|
Up |
|
|
  |
Author: John PassanitiJohn Passaniti Date: Sep 19, 2008 08:51
Let's start with what I'm not interested in. I'm not interested in a
debate on different version control systems or on the usefulness of
version control in general.
What I am interested in is what *existing* strategies may have been used
in the past (or are used now) for doing version control using Forths
that stored source using *true* blocks.
Note carefully that I make two qualifications here: First, I'm only
interested in *existing* strategies because I'm looking for something
that has been proven by others, not an abstract discussion about what
possibly could be done. Second, I'm asking about Forth systems that are
based on *true* blocks, not blocks implemented on top of files since the
trivial answer in that case would be to version control the files
holding blocks.
I appreciate that such a version control system might be ultra-minimal
and not offer features like branching, tagging, differencing, and
merging, etc.. It might only offer manual roll-back of a specific block
to a prior state, or possibly a grand snapshot of all blocks captured at
a particular point in time. Whateve
-- I'm just looking for past
strategies.
|
| |
|
| | 36 Comments |
|
  |
Author: Jean-François MichaudJean-François Michaud Date: Sep 19, 2008 09:18
On Sep 19, 8:51Â am, John Passaniti JapanIsShinto.com> wrote:
> Let's start with what I'm not interested in. Â I'm not interested in a
> debate on different version control systems or on the usefulness of
> version control in general.
>
> What I am interested in is what *existing* strategies may have been used
> in the past (or are used now) for doing version control using Forths
> that stored source using *true* blocks.
>
> Note carefully that I make two qualifications here: Â First, I'm only
> interested in *existing* strategies because I'm looking for something
> that has been proven by others, not an abstract discussion about what
> possibly could be done. Â Second, I'm asking about Forth systems that are
> based on *true* blocks, not blocks implemented on top of files since the
> trivial answer in that case would be to version control the files
> holding blocks.
>
> I appreciate that such a version control system might be ultra-minimal
> and not offer features like branching, tagging, differencing, and
> merging, etc.. Â It might only offer manual roll-back of a specific block ...
|
| Show full article (1.48Kb) |
|
| | no comments |
|
  |
Author: Jean-François MichaudJean-François Michaud Date: Sep 19, 2008 09:37
On Sep 19, 9:18 am, Jean-François Michaud comcast.net> wrote:
> On Sep 19, 8:51Â am, John Passaniti JapanIsShinto.com> wrote:
>
>
>
>> Let's start with what I'm not interested in. Â I'm not interested in a
>> debate on different version control systems or on the usefulness of
>> version control in general.
>
>> What I am interested in is what *existing* strategies may have been used
>> in the past (or are used now) for doing version control using Forths
>> that stored source using *true* blocks.
>
>> Note carefully that I make two qualifications here: Â First, I'm only
>> interested in *existing* strategies because I'm looking for something
>> that has been proven by others, not an abstract discussion about what
>> possibly could be done. Â Second, I'm asking about Forth systems that are
>> based on *true* blocks, not blocks implemented on top of files since the
>> trivial answer in that case would be to version control the files
>> holding blocks. ...
|
| Show full article (2.89Kb) |
| no comments |
|
  |
Author: John DotyJohn Doty Date: Sep 19, 2008 09:43
John Passaniti wrote:
> Let's start with what I'm not interested in. I'm not interested in a
> debate on different version control systems or on the usefulness of
> version control in general.
>
> What I am interested in is what *existing* strategies may have been used
> in the past (or are used now) for doing version control using Forths
> that stored source using *true* blocks.
Well, a quarter century ago I briefly set up a system that sent the
blocks out over a serial line to a UNIX server which stored them in a
file, which was then placed under RCS. Worked fine, but rapidly mutated
into an approach where the field systems just kept binary images in
their block devices, with source on the UNIX servers. Handier.
>
> Note carefully that I make two qualifications here: First, I'm only
> interested in *existing* strategies because I'm looking for something
> that has been proven by others, not an abstract discussion...
|
| Show full article (2.36Kb) |
| no comments |
|
  |
Author: John PassanitiJohn Passaniti Date: Sep 19, 2008 09:44
Jean-François Michaud wrote:
> Are you looking for past strategies or current strategies (or both)?
> You context seems to imply you're interested in both but in each
> individual reference, you only want one or the other.
I thought I was clear. I'm looking for *existing* strategies. Those
can be from the past or currently in use.
|
| |
| no comments |
|
  |
Author: John PassanitiJohn Passaniti Date: Sep 19, 2008 09:55
Jean-François Michaud wrote:
> A simpler approach is to simply store the entire block while tying a
> version number to it. Pulling the version is as simple as looking up
> the associated pairs (version and block). This is simple to implement
> but will rapidly become bulky space-wise; check-in/check-out is
> necessary here as well. The same "multi" function applies under the
> bulky solution. Rollback is the same as previously mentioned except
> that here we delete whole blocks instead of deltas.
Again, I'm not looking for a discussion on how to implement this. I am
interested in existing strategies that others may have used because I'm
looking for proven approaches, not an abstract discussion about how I
might choose to implement this.
The answer may simply be that nobody had ever implemented version
control in block-based systems. That's fine, and if so it tells me that
I'm not going to be considering proven approaches but something I invent
for the particular project I'm considering.
|
| |
| no comments |
|
  |
Author: John PassanitiJohn Passaniti Date: Sep 19, 2008 10:00
John Doty wrote:
> I'm not sure what your real requirement is: you need to function
> entirely within a block world? When we did that we just made a floppy
> with a snapshot whenever we would have made a commit. Wound up with
> boxes of labeled, dated floppies. Start a new fork, start a new box ;-).
> I suppose you could do the same with CD's. Cheap and simple enough...
I didn't want to discuss my application because it doesn't matter. I'm
interested in what others have done both to learn about past solutions
and from a simple computer history perspective.
Thanks for your comments.
|
| |
| no comments |
|
  |
Author: John DotyJohn Doty Date: Sep 19, 2008 10:20
John Passaniti wrote:
> John Doty wrote:
>> I'm not sure what your real requirement is: you need to function
>> entirely within a block world? When we did that we just made a floppy
>> with a snapshot whenever we would have made a commit. Wound up with
>> boxes of labeled, dated floppies. Start a new fork, start a new box
>> ;-). I suppose you could do the same with CD's. Cheap and simple
>> enough...
>
> I didn't want to discuss my application because it doesn't matter.
That's where your outlook differs fundamentally from mine. The
application *always* matters. It matters more than anything else. But we
also disagree on what "application" means. Applications are things like
selling soap and finding planets. The computer and its code are tools.
|
| Show full article (1.20Kb) |
| no comments |
|
  |
Author: foxchipfoxchip Date: Sep 19, 2008 10:38
On Sep 19, 8:51Â am, John Passaniti JapanIsShinto.com> wrote:
> I'm just looking for past strategies.
A block that contains the current and previous checksums for all
blocks,
a word to show changed blocks, and an archive of release versions by
date.
|
| |
| no comments |
|
  |
|
|
  |
Author: Jean-François MichaudJean-François Michaud Date: Sep 19, 2008 10:40
On Sep 19, 9:55Â am, John Passaniti JapanIsShinto.com> wrote:
> Jean-François Michaud wrote:
>> A simpler approach is to simply store the entire block while tying a
>> version number to it. Pulling the version is as simple as looking up
>> the associated pairs (version and block). This is simple to implement
>> but will rapidly become bulky space-wise; check-in/check-out is
>> necessary here as well. The same "multi" function applies under the
>> bulky solution. Rollback is the same as previously mentioned except
>> that here we delete whole blocks instead of deltas.
>
> Again, I'm not looking for a discussion on how to implement this. Â I am
> interested in existing strategies that others may have used because I'm
> looking for proven approaches, not an abstract discussion about...
|
| Show full article (1.77Kb) |
| no comments |
|
|
|
|