Davou,

I just refreshed the concept of finite state machine 
<https://en.wikipedia.org/wiki/Finite-state_machine> and I would be 
confident in saying tiddlywiki is not one. You may see elsewhere and 
reasonable claim tiddlywiki is a "non-trivial quine", it can change itself 
and save its state.

This is because an  finite state machine 
<https://en.wikipedia.org/wiki/Finite-state_machine>'s memory is limited by 
the number of states it has, tiddlywiki is not, and its memory limitations 
are in undetermined.

However I suspect the reason you think this may be the case is reasonable, 
but would argue that this mostly stems from tiddlywiki being used in the 
browser. Along with other websites and even much earlier Mainframe 
terminals the client server model a need to limit the effort required by 
the server html tends to respond to a client when needed and not until 
then. Think of a html form, it sits on your screen and the server may be 
able to forget you exist until you hit the submit button, at which point 
the server/host responds. Tiddlywiki however exists wholy within the 
browser and only on saving do we need to communicate with the server/host.

Tiddlywiki's update process that reflects any change throughout the whole 
wiki, makes use of a thing call widget trees, examples such as 
transclusions need to be resolved based on any relevant change. However 
such could result in infinite loops but tiddlywiki is designed to avoid 
this. Basically it works to ensure each change is processed in a finite way 
so it returns quickly to allow the user to interact or provide more data to 
it. 

I feel that tiddlywiki is better thought of as an approximation of a Turing 
machine that handles most freeze, fails and infinite regress (although not 
all).

Part of the complexity comes on one hand from the feature rich code and 
services available to software in the modern browser and on the other hand 
it can be hosted such that changes can't be saved. It could be argued a 
read only tiddlywiki has finite states, however there are so many states it 
can be in, it may as well be infinite.

Thanks for posting such ideas.
Tones
On Tuesday, 10 August 2021 at 03:01:42 UTC+10 davou...@gmail.com wrote:

>
> Hello all,
>
> I've been casually using TW for a few months now. In the past couple weeks 
> I have started working with the slightly more advanced features. 
> https://groktiddlywiki.com/read/ has been very helpful, thanks Soren. One 
> of the obstacles for me to grok TW is there appears to be a lot of 
> conditional rules based on the current context of the parser - ex: in 
> tiddler text vs macro call vs macro definition. This makes me visualize TW 
> as a finite state machine. Maybe it's actually designed as such, I haven't 
> looked at the code. Anyway, the nice explanation by PMario here 
> <https://groups.google.com/g/tiddlywiki/c/RoTA7OJFMMg/m/sjnaY93TBgAJ>just 
> bolstered my visualization.
>
> I don't suppose there is documentation of TW as finite state machine. 
> Probably not, but thought I would ask. What I mean is documentation broken 
> down as:
>
>    1. Here are all the possible states TW can be in
>    2. Here are the rules for when TW is in a given state
>    3. And here are the triggers that will change TW from one state to 
>    another
>    
> Maybe there are too many states, or may different levels/granularities of 
> states.
>
> The closest I found is Tones' https://anthonymuscio.github.io/It has many 
> of the rules for a given "state".
>
> Thank you.
>
>

-- 
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to tiddlywiki+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/8beca877-9821-4aa4-90c2-1052527a6be6n%40googlegroups.com.

Reply via email to