On Wed, 22 May 2013, G.J.Robert wrote:
Let's recall when TiddlyWiki just get so well noticed in it's 1.x age.
There was an adaptation called "LesserWiki" if some people remember it.
(discontinued long ago and sadly I can't even find it's official site now)
It seemed to use AJAX methods behind the curtain so every tiddler was
retrieved when a link is clicked (a throbber indicating the loading is in
progress). Ever since seeing it, I've always hoped that TiddlyWiki itself
has this kind of serverside backend. I imagined that on page loading only
necessary frame codes and plugins are loaded and rendered, with of course
the DefaultTiddlers and tiddler transcluded on Sidebar, MainMenu, Topbar
etc. are loaded at the first place. The rest of all the tiddlers are
treated like a backend database and are only retrieved when being
clicked/searched/inquired for.
This sort of thing is technically possible, and is how I always
hoped/imagined dynamic or lazy loading would work but it has all the
problems you imply here
Of course as I further used and got knowledge about a little how TW works,
I realized that making modern TW (even the classic edition) load lazily
with so many transclusions, plugins, layout and environment settings is
definitely not easy. For example, how will ForEachTiddlerPlugin behave when
most of the tiddlers are not loaded at all? Will it throw complete and
desirable output when the macro is executed? Will it take too long as
loading the whole TiddlyWiki? And what I'm thinking may go way too far from
the original design of TiddlyWiki as a single HTML file with all tiddler
data as loaded but hidden divs.
as well as issues with search, timeline (and other info tabs).
As a result things rather stall out. The basic situation is that it is
possible to do a dynamic (and yes that is a better term) loading
TiddlyWiki but only if you want to throw away a lot of the features
that make TiddlyWiki special.
Therefore it becomes necessary to explore the idea of loading an
initial basic TiddlyWiki and then loading in the rest of the content
as individual tiddlers, and then starting the app.
My biggest wish is the AJAX "on demand" way, but at least, I like enough
the way "@apps _tiddlywiki" loads the spaces. Although it is not "on demand
loading", but it does reduce the initial time to render the page frame and
does load all the data eventually after very acceptable delay. If I can
find a direction to pay suggestions, how about distinguishing more clearly
between those tiddlers definitely needed initially (all the plugins,
stylesheets and tiddlers making up the whole layout) and those irrelevant
to the structure (only playing as data), and making sure that the necessary
ones get loaded first, so that the initial page is 100% usable and
correctly operational? Pardon me if this is not the problem now.
I think it doesn't load as effectively as it should. There's
definitely room for improvement. Looking at the code it seems to not
be taking as advantage of potential parallelisms in the browser as it
could.
If that were fixed it is likely the lazy loading might be relatively
effective, assuming we define lazy as:
1 load the app framing
2 load the content in parallel
3 start the app
That's different from what's currently being done, which is ordered as
1, 3, 2 (with bad parallelism).
--
Chris Dent http://burningchrome.com/
[...]
--
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 [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.
