Best Practice: Tiddlywiki and Structure of Long Note

  • The nature of most academic text is they are lengthy
  • Chunking is a technique, breaking down a difficult text into more manageable pieces, where Tiddlywiki is best for doing that

Considering the above items, still in most cases the length of a chunk causes to create a big, long tiddler!

One example: For a homework in an engineering class, the homework has title, description, equations, problem data, questions, references, due date, … then we have the solution etc.

During semester, we have around 32 homework, keeping the wiki for several years cause a large number of tiddlers

So, in brief:

  1. what is the best practice to use Tiddlywiki for lengthy texts like homework, or problem solution?
  2. considering the philosophy of tiddler, do you write each section of a lengthy note in a separate tiddler? if so, don’t you think your tiddlywiki soon gets crowded and difficult to search and maintain…?
1 Like

Good Question Mohammad.

My thoughts;

  • If you build a long tiddler in a single session and don’t have the opportunity to divide it as you go, in a revision process you could come back and divide it into logical units.
  • However if you had the right tools or standards available while writing you could indicate the logical divisions as you type, then programaticaly divide later.
  • In all cases where you divide a larger tiddler into smaller tiddlers I think making use of the concept of a “compound” tiddler makes sense. Examples include using streams.
  • If we provide the tools to break tiddlers up, we should also have the tools to rejoin them if possible. For example have an ordered list in the side bar of component tiddlers and drop them on a compound tiddler to bring the content together.

One feature available to us I do not think we have made much use of yet is arbitrary html tags. It is possible to make up a tag as you go eg;
chapter

<chapter>
A Chapter of content
</chapter>

This is just a logical arrangement of your content and is most likely based on something you know while you are writing. It could also be facilitated with an editor toolbar drop down with various tags, even tags you accrue over time, or just in the current tiddler. Perhaps starting with a subset of the block elements.

Subsequent to your initial composition you can do the following with content so structured.

  • Apply a standard CSS to each of the same tags class or styles
  • add a title=“tooltip over whole chapter”
  • Programmatically convert the “chapters” into subtiddlers whist keeping a compound tiddler.
  • Even hierarchical or nested “decomposition” could be developed.
  • Each time we generate a sub-tiddler, depending on a separate “mode” setting, each sub tiddler can now have tags, descriptions, summaries, excerpts, captions, categories or any other attribute or feature we want to design. This can be done from a compound tiddler view or on individual tiddlers.
  • With sub-tiddlers we can reorder, reuse, search according to content, fields and tags on the separate tiddlers rather than the whole tiddler.

In relation to searching compound tiddlers, I recently invented for myself a search that first renders a tiddler and searches in the result so you can find the content generated by widget and lists and transclusions, in both it’s sub tiddler and in its parent. Marking compound tiddlers as such helps with performance.

Now back to your original question

Still in most cases the length of a chunk causes to create a big, long tiddler!

If this is a long tiddler because it becomes a compound tiddler then we have the opportunity to introduce various navigation support, tables of contents, internal search, indexes, scrolling, sliders etc…

What do you think?

1 Like

Thanks @Mohammad for raising the question (one i struggle w/ a lot!) and to you @TW_Tones for the long list of possible approaches -some of which i use (Streams in particular is the one most helpful to me), and others of which i’ve never tried (e.g. tooltips, html tags, CSS templates), but will explore.

The one thing i must add is: because long-form writing is by its nature a thing not finished in a single session (usually), this implies a need for workflow management, with maybe some specialised tools & techniques to support it. For example: @sobjornstad developed some nifty lightweight tooling in form of a “Write” tab, in context of his Zettelkasten, which you can see demonstrated in this section of YouTube video he published last spring. It is essentially a sidebar tab w/ subsections holding content that is tagged according to where it sits in your writing workflow- e.g. “Needs Excision” vs “Stub” representing two obviously different stages in the process. For developing long-form content that is ultimately destined for publication, i have found this method to be a real productivity-booster.

In fact: absent any such workflow tooling, i wonder how it could even be possible to produce a book like the amazing Grok TiddlyWiki; would love to hear more from Soren (and other wiki-powered publishers in this group) about writing workflow.

2 Likes

I may sound like a broken record, but here it is: I would approach it with Streams.

Here are a few reasons why I like the approach:

  • it breaks up the long text into manageable chunks (nodes)
  • each node can be edited rapidly by double-clicking it; avoiding the need to find the place to make a change in a long tiddler
  • the nodes can be re-arranged by drag and drop (or even keyboard)
  • the nodes can be hierarchized (placed in a hierarchy). Hierarchies can be rolled and unrolled when viewing
  • each node is a tiddler in its own right (supporting rich text and transclusions); in that sense, it can encapsulates one “short” context in the spirit of TiddlyWiki
  • these nodes can be moved and/or copied (with your mouse) between tiddlers if you re-organize your thoughts more fundamentally
  • it is relatively easy to fuse and export the hierarchy if needed (for onward sharing, conversion, publication); it’s the ultimate tool to edit

One element I do change from default Streams configuration is the enter key shortcut. In my setup, each node is a short paragraph or section (that can include line returns) rather than a single line. I change the streams-save-and-continue shortcut to shift-enter

There were two key tools I developed for it:

  • Reordering tools – quickly drag and drop sections and chapters around. I moved things quite a bit before I decided on the final order, so being able to quickly bump things was important.
  • TODO list – working exactly like the one I now have in my Zettelkasten, writing a link to TODO anywhere in a tiddler would automatically add an entry in my meta tiddler pointing directly to the section that needed something done to it.

Other than that, my writing process was mostly a big long list of things to write, change, or improve which I added to when I had ideas and removed from as I worked on the book. Not very exciting, but functional.


A related challenge with any creation this long, whether it’s a book, a software program, or something else entirely, is silent dependencies and cross-references between sections. For instance, the exercises in GTW involve a sort of “implied wiki” – it’s not actually in the book anywhere, but the user is creating a wiki based on the exercises as they go through the book, and for many of the exercises the implied wiki needs to be in a particular state. Making changes to one of the exercises can change that state, and it’s extremely tricky to recognize this as an author unless you just happen to remember that your change will influence something further through the book; obviously it’s not practical to read through every exercise to see if it might have an effect, even if you could be confident you would notice there would be an effect when you saw the exercise.

For something which is published once and is done, this isn’t all that big a deal, as you can just do all of the exercises a couple times, or have a first round of readers do them, and fix any problems that you spot. For GTW, which has to be continually updated to follow the changes in TiddlyWiki, this gets harder. I’m more or less stuck relying on users to send me feedback indicating that something’s wrong right now. (I get feedback of some sort almost every day, so this seems to be proving a fairly effective approach, but it’s too early to know for sure, and obviously it’s frustrating for someone to have to run into a problem before the book can be fixed.)

Takeaways in GTW have a similar problem, though this one is not as bad because changes to a section usually only affect takeaways within that section, so it’s practical to look at all of them and see if any need to be updated.

If the topics / sections / paragraphs were split into small enough units, I could imagine keeping track of some of these dependencies directly with a list field or something. I’m suspicious this might have a negative ROI though…if you’re working on a big project like a book, you tend to do a pretty decent job holding this kind of thing in your head, and tracking the dependencies within the text would be quite a lot of work. If you could come up with some creative way to use the dependencies to let the user navigate through the text, that might redeem the project since you’d be getting several things out of it.

This is getting a little off-topic into GTW’s problems specifically, but it would be interesting to see if some kind of “automated testing” could be developed to verify whether the exercises behave correctly when put together. That sounds fanciful, but while complicated I think it could actually be pretty doable. As an example, Python has doctest, which can programmatically verify that all the examples in your API documentation work. The “output” to be tested in our case would be the HTML generated by the rendering of a particular tiddler (this would cover most, but not all, things that could be wrong with the exercises – for instance, wrong instructions about what buttons to click to accomplish some task wouldn’t be caught this way). The structure of exercises and their answers would change a little bit so that the test framework could apply the answers to a fresh wiki, each exercise in turn. This could also make it possible for readers to grab a copy of the wiki at any stage and inspect it or continue working from there…in effect turning it from an “implied wiki” into an explicit one.

1 Like

To better explain the question and my current approach see attached image created from a rather lengthy tiddler.

Screenshot of Exothermic CSTR tiddler

My current approch

  1. Create a master tiddler. As an example here a tiddler called Exothermic CSTR
  2. Create all subtiddlers with name prefixed with Exothermic CSTR/ like Exothermic CSTR/Description or Exothermic CSTR/Description P01
  3. Put the below code in master tiddler to generate the contents from subtiddlers. I assume you have Shiraz plugin installed
<$list filter="[tag<currentTiddler>!has[draft.of]!tag[image]]">
<$macrocall $name="details" label={{!!caption}} src=<<currentTiddler>> status="open" labelClass="alert alert-secondary py-1 my-2" srcClass="alert border-secondary py-0"/>
</$list>
  1. Tag the master tiddler with Contents. The Contents tags is used to create table of content in the sidebar

The process seems easy but

  • you have a lot of subtiddlers
  • search is difficult as you see many irrelevant results
  • TW gets crowded untidy soon

@sobjornstad - do you link directly to some inner points like a heading? or just to the tiddler?

@fastfreddy - yes Stream is quite a powerful tool!
Here for creating course notes, mini books, pamphlets, etc. I need a bigger chunk and a workflow to produce chapters, headings, subheadings, …

Hi Mohammad

You have sliders in your screenshot. You might consider my Subsume-edit plugin to break up the pieces of your long tiddler. The edit button is right next to the header, so you can not only compress the sliders but access the underlying tiddlers quickly. No sidebar tab needed.

Also, I don’t see that anyone has mentioned prefixes as a way to distinguish types of tiddlers (data, duedate, questions, references, etc) could each have short abbreviations, and you could transclude them, or subsume them with a caption.

Those are the two ideas that came to the top of my head regarding managing long tiddlers.

1 Like

@TW_Tones - very good tips and tricks. I saved your tips in my wiki for further references.

I use some of them, still looking for a more straight forward approaches.

@ludwa6 - I am not sure, but I think we need some tools when creating a long tiddler!
Shiraz has some tools to do this and I use a customized TOC plugin to create subtiddlers!

subsume is a good tool to break down long text! You may think to customize the details style!

img_533_%pn

Don’t forget Notowritey :cry:

2 Likes

@Mark_S
I love it for outlining! :heart_eyes:

Yes, feel free to adjust $:/plugins/giffmex/subsume/stylesheet to your liking!

Use a tree structure so it doesn’t get untidy and you’re not overwhelmed by tiddlers. Use a search at each node tiddler so you’re only searching within context. Since it’s a list, or tree, you might also have students view and instructors views.

3 Likes

another option I came across is the Paragraphs plugin. I have not compared to Subsume, it feels like Subsume provides all of what Paragraphs can and more, but I may have overlooked something and for completeness, may be worth looking at Paragraphs also…

Elaborating a bit more, the other advantage of tree (usually tag) based structures is if you are handing out the TW’s for homework assignments. With a tree, displaying captions, you could change the names of all the tiddlers per student or some other serialization. You might have a role field explaining the intent of the tiddler (e.g. hw-solutions-exothermic-CSTR). At some point you might want to compare all the homework responses to see how well the learning has gone. You could import the homework assignments and compare them side-by-side. Because they have different titles, they won’t override each other.

With a link-based (macro) solution, this would not be so practical since changing titles would break the linking.

I hadn’t seen the Paragraphs plugin. That’s a great add for the filter option!

Mark, I did not get how you have a tiddy TW?
does it mean to hide or not use Recent and More tabs and standard search?

If we search in TOC, does it expand sub branch automatically?

Of course having a customized search, lets us to decide search in text/captions/keywords/duedate …

You have your own master tiddler that generates the rest of the document, or a view of the document.

Sadly, it does not automatically search sub-branches or expand branches. But I can imagine a search possibly using the kin plugin that searches downwards and creates the appropriate flags so the branches are open/closed.