skipping versioning for small edits

4.26: adde/versioning/skipping versioning for small edits:
. while inputting a string,
when the normal rules of versioning are in play,
stopping to do a correction should
cause the string input to be terminated,
then the new command is a string replace .

. one way around that is [word modify mode]
that can suspend the versioning system
until you are finished editing a particular word;
and, it reduces the damage of the modification
to just a particular word,
so that the versioning system is less needed . 5.13:
. it doesn't consider the word saved by versioning
until you are actually getting into the next word .

save without crash-corrupting log file

4.21: adde/journaling/save without crash-corrupting log file:
. when saving the user's commands log,
each save needs to re-open and re-close the file;
because, a crash when a file is open might corrupt it .
. this could be done using a pair of files;
or we could use the platform's way of writing to a file buffer;
and then atomically set the save-file's pointer to point at buffer;
or (copy saved; append the command; close the copy;
    rename copy as saved).

journaling . elder care helps dev's too

6.1: adde/journaling/elder care helps dev's too:

. so many computer problems and clues;

trouble trusting my mem now ...

. computers for elders definitely aren't here yet!

we need a modular architecture

where no app does anything

-- inputting our outputting --

without a log recording it .

. you would think this is

the first thing designers would do;

they are always fielding calls like:

"( I don't know what I did .

how can reproduce the problem?)

and always giving advice like:

"( please be aware

of every little keystroke you make;

so that you can recreate the problem,

noting (eg, logging)

what conditions are triggering the behavior

-- the platform, its config', and your input).

journaling with efficient versioning

2.11: adde/journaling/efficient versioning:

. notice reverse diff can't be done by journaling,
needs exact replace commands:
eg, suppose block has x's
and I use command to replace all x's with y's,
but there are already y's .
then a reverse journal changing y's back to x's
is going to change too many y's
and therefore won't represent the previous version .
. reversing must keep track of either whole block versions
or use address of changes
-- in some cases the instruction for reverse
would be heavier than just keeping both versions .

versioning

1.27: adde/versioning:
. another way to handle conflicts in versioning
is to treat them like c`pre-processor conditionals:
you would give the conditions under which
one version or the other would be selected for viewing .

adde's journaling

todo.unreadable: 8.7: adde/journaling/assuring privacy:

. how to assure logging without key logger vulnerabilities?

3 types of log:

( sw config

, user cmd input

, user data input (content and pass )

) . the system must insure (verify)

that outcome doesn't depend on user content .

. the exception is when content includes scripts .

. if script affects only content

then the only thing to report is the allowed cpu and mem access .

. general scripts are part of software,

and become part of system config'

-- or need log of subset of system accessed .

log of pass and content is replaced with

cmd of get these from user .

--. inputs assumed to filter checking type and string`length .

. log also includes a ptr of use only locally

describing where the content is stored .

. the pass needs an id too (which pass did I use ?),

you have an id made like file names (creation date, owner) .

journaling wave-oriented

6.7:
. upon hearing about a terminal app with tabs
(so you can have several sessions
in one window like a web browser)
I was reminded of google`wave managing communications .
. this inspired me to have adde
going beyond file-oriented journaling,
to journaling the interactions between
all processors and projects .
[7.6: by "processor" I mean the human or autonomous user
of a tool that can edit a project;
journalling is another term for unlimited undo
or revision control]
--. google's wave is named after EM waves,
the electromagnetic vehicle by which
all objects in physics telecommunicate (ie,
transmit energy without particles bumping into each other) .