TiddlyWiki is very powerful but gives too much freedom to new users. I lost myself: A story and an idea

#13

To sum up the thread: with great power comes great responsibility :laughing:

This is a very important insight. I myself have many times struggled with how to do a thing in TW, only to realize later that I don’t actually need it to manage my notes, I just thought I did. This reminds me of the XY problem. A recent example thread, where the question of how to do a thing evolves into why even do a thing and what to do instead: Auto-appending a field - Discussion - Talk TW (tiddlywiki.org).

How to avoid this? A better presentation and focus on the not-too-overblown editions or examples for specific use-cases as discussed above would surely help.

My own three cents: I’m not a fan of directly using the heavily modified editions (like Memory Keeper, Stroll, or tzk), but I value them as an inspiration to develop my own, often similar approaches.
This is of course much more time consuming and many users will prefer to just grab a ready solution.

I think to make the general/beginner editions most useful, they should not be overloaded with features and ideally composed of removable plugins.

3 Likes
#14

Yes. Edition is the name for such a “single purpose” wiki.

#15

I subscribe, really interesting

Indeed you are right. I was thinking more of a “median” tiddlywiki, which would actually be better than empty, but rarely really good for anyone.

I said this because finding multiple editions for every need seemed like a big task to me and I preferred to propose something simple initially. But if these editions already exist/are easy to compile, that would be optimal. But yes, I agree, there is no “average” TiddlyWiki user. And that’s great.

I don’t know what would be the best way to present them, but if this could be done, this could really give direction to new users

Oh, that certainly is/was the case with me. This is certainly the case, because I often don’t know what I want from TiddlyWiki, but also because I often don’t even know what I might want. For example: I could do without the autocomplete plugin, I would still use TiddlyWiki even without it, but once I discovered it I found that it’s very convenient and I wanted to have it from the start and it’s something I want to keep using.

I certainly don’t have a perfectly clear idea of ​​what my “ideal” TiddlyWiki would be, I agree. But after more than a year I have now reached what is “pretty close to my ideal”.

  • But for this very reason, in my opinion, it is even more necessary to create a guide made by the community. Together with our collective experience, we have an idea (not perfect, it’s true, but still good and useful) of what a user may need.

    Leaving the user alone, who doesn’t even know what he would like, without clear knowledge of what he can get from TiddlyWiki is not good.
    He will have the opportunity to experiment on his own starting from the (so to speak) “guide-editions” of those who have known TiddlyWiki for a long time

In fact, I believe that for an inexperienced user it is even more difficult to recognize which functions are commonly useful and which, however ingenious, are only useful to some users/only for certain types of use of TiddlyWiki.

(e.g. A plugin that manages checkboxes can be essential for a planner, but almost completely useless for taking notes, and perhaps the inexperienced user doesn’t realize it.)

This is why I believe that “curated editions” could be realy useful; to guide the first stemps of the new or inexperienced user.

Me neither, I find them too structured (very well made - perhaps too much :joy:) but structured enough to leave the user with less freedom of customization.

#16

Unfortunately I don’t have time to do it now, but I’ll be back as soon as I can

#17

I use TiddlyWiki to take notes and to log information:
Lots of short tiddlers, where I fill out multiple fields.

My biggest need is speed: For tiddler creation, compilation, search and consultation.

Some of the main features I have implemented/plan to finish implementing in my TiddlyWiki:

  • The “+” button offers more templates to choose from (e.g. create a document tiddler, an idea tiddler, journal etc.)
  • In the tiddler, following the templates, I already have “chosen” fields ready to be filled in (I saw a similar thing in MemoryKeeper)
  • Once I have a lot of tiddlers, I can look at them using the TiddlyTables plugin to quickly compare and view them. (I’m still trying to make improvements to this plugin. Work in progress)
  • For other tiddlers I find it convenient to use the WizardNav plugin
  • Thing I’m struggling with a bit: finding tiddlers. I’m not at all an expert with filters but I’m trying to build a tiddler to keep in the sidebar similar to the one you can find in EberronTiddlywiki (Find Things) https://eberron.tiddlyhost.com/#Find%20Things

Some tools that I use and find very useful:

  • Bookmarks is a feature that I find really useful (The tiddlers that I always have open by default when I open tiddlywiki are the ones that I tagged with “bookmark”) For this I didn’t use plugins, I know they exist, but I did it myself.
  • Autocomplete plugin is also something that helps me do things faster
  • Link to tabs plugin, fundamental for me, but i rekon that for a user who doesn’t customize much or who isn’t interested in looking “behind the scenes” it is not very useful
  • Relink plugin. I don’t think there’s much to say, I think this should almost be part of the core
  • Tiddler commander plugin: maybe a new user won’t use it often, but it is a very powerful tool that I highly recommend

What I would still like to do: (projects that I have started but have only half done)

  • A template builder, and a tiddler constructor like this one: Demos — Q&A and tools for tiddlywiki (I made some templates for myself but they are not really good yet)
  • A filter helper/builder.
    (it doesn’t have to be perfect or cover every case, but especially for searching for tiddlers it would be very convenient. It would also be “educational”: by using it you get an idea of ​​what the main filter structures are)
    Or in any case a very flexible search system that does a bit like the “Find Things” I mentioned before
  • Some changes to TiddlyTables (especially column searches and ways to sort information)

I talk a lot about search and filters because I think that’s the biggest gap in the “empty” TiddlyWiki. Creating tiddlers is easy even for an illiterate, but finding them, creating tables or tables of content where you can easily collect them or search for them requires a bit of ingenuity.

This is only my particular case:
I say that some of these needs of mine are common (such as the use of “Relink”) while others I am sure are only my problem.

I’m tempted to say that these things would be useful to everyone :sweat_smile:, but I only know my particular case, so for the “average user” (assuming it exists) or in any case the average user of a particular TiddlyWiki, I think it would be useful to see what the community thinks.

(What is useful for a note-taking TiddlyWiki? What is useful for a personal journal TiddlyWiki? …)

  • Perhaps a poll could be useful in witch we ask what functions we feel are the most important to have when starting TiddlyWiki or anyway what functions or plugins you are most likeliy to reccomend.
2 Likes
#18

I appreciate the thoughtful, in-depth response!

This is something I’ve fantasized about myself, though I haven’t put much work into it. I really like what @Mohammad did with the popup menu in this demo, though an ideal solution would be layout-agnostic. I imagine it would still have to depend on the user defining buttons and templates to be included.

You might be interested in @EricShulman’s filter generators, and perhaps particularly in his PowerSearch. Unfortunately I didn’t find this myself until after the point at which it would have been most useful to me; these days I’m generally using a wider range of filter operators than it supports, and it’s quicker just to write the filter myself. But I do really appreciate that it shows you the full filter, as you’ve constructed it, in addition to the search results it produces.

Personally, I use (a slightly modified version of) Command Palette for nearly all my search and navigation needs—though I’d hesitate to recommend it for inclusion in a starter edition as it hasn’t been updated in more than a year, and the official version can be difficult to customize. Even so, it’s game-changing to be able to pull up a search bar with a hotkey, and I find it much faster than opening the sidebar (and then probably opening Advanced Search anyway).

Ditto! I like Favorites, personally, for the ability to sort into “folders” and quickly populate a folder with a filter.

Autocomplete, Link to Tabs, Relink, and Commander are also excellent picks (and I’d also agree that Relink should be part of the core).

Eric’s Power Search may be a good starting point!

I think you’re absolutely right that filters are one of the biggest (if not the biggest) pain points for new and even experienced users, and having an interactive model for what a properly formatted filter should look like would be a huge boon. Ideally, it would include some options for working with variables or transcluded fields, too; that might clear up some of the inevitable confusion about when and how to use each type of bracket (certainly a major hurdle for me when I was getting started). But as you said, even a relatively basic builder would be educational—and perhaps worth including on the main site, as a companion to the filter documentation.

I haven’t used it myself (and the demo site may need a little Google Translate), but I wonder if @linonetwo’s Template List plugin would fill some of this need.

2 Likes
#19

The separate filter generators file is obsolete and all the “filter generators” are now hosted directly on the main TiddlyTools.com page. See the “Search” tab in the “Welcome to TiddlyTools” tiddler.

In particular, PowerSearch (now simply called Search/Filters) is here: https://TiddlyTools.com/#TiddlyTools%2FSearch%2FFilters

-e

4 Likes
#20

Also, genealogy! (a common non-coder project that may bring people to TW’s power, and which we already have some great models of)

AND, surely a working bibliographic database (with quotes and notes) would be of broad interest too. The RefNotes plugin is amazing, and is well-documented. It even has some live example tiddlers. Still, it shows very little about how those tiddlers can be connected up for dynamic purposes, and the GUI for “taking it for a spin” is densely interwoven with explanatory text. I’m close to being able to share a version of my biblio-research tool that uses Mohammad’s plugins and also some original templating, css tricks, and virtual nodes (what shows at a tag even if it’s “missing” as a tiddler). It might have a tutorial “layer” available (including notes about the various plugins and other moving pieces of the solution), but will mostly be a ground-level demo: “surf around and see the end-product power”.

I wonder if there’s a way that plugins such as RefNotes (or a recipe database, etc.) could have TWO tiers of shadow tiddlers: one is the ordinary shadows that always exist but can be overridden; the other is a set of meaningful sample content that can be sent underground once someone understands how things work. (And maybe it can be easily “resurfaced” to poke into a feature that’s newly interesting.) Alternately, a plugin developer could try to host a demo site that is not just a minimal proof-of-concept with documentation, but a “watch it in action” application.

To some degree, the Shiraz demo is already like this, since it uses Shiraz affordances to offer a tour through Shiraz.

Still, sometimes newcomers to TW can get dizzy when the quine-factor (“Now look at this very code performing surgery on itself!”) is too daunting. Having a non-technical domain for the “topic” of the demo, so it’s easier to separate target-domain from the specific tool-affordances to explore, can help here.

Proposed guideline for sample content of such editions (with apologies if these ideas have been hashed out elsewhere!): Content should include enough real-world substance to allow a decently-powerful tour through the core set of affordances related to the project. It should not have any lorem ipsum, let alone “foo” and “bar” values in fields. It should be the kind of stuff whose familiar-feeling content can help to make the interface feel more intuitive. AND all of that real-world content ought to be easily deleted or hidden (in someone’s cloned copy) so that users can easily feel like they’re moving into an AirBnB that has all the appliances and furniture, but nobody else’s clothes in the closet. :wink:

6 Likes
#21

Which puts me in mind of Dialectical Journals.

1 Like
#22

Of course. And many, many more. That’s part of the challenge. I could have listed a dozen more without searching.

Yes, that’s what we’d want, but ideally not with an overwhelming amount content. Perhaps we need an edition wiki, which is the empty infrastructure with some minimal documentation of how to use it alongside an in-action example of a wiki built on that edition. A recipes wiki would probably have to have three or four categories with 20 - 50 recipes, not the 792 recipes in your personal cookbook (not counting Auntie Frieda’s weird gumbo!)

I’m pretty sure that would be straightforward, with one significant caveat. We could wrap those tiddlers in a plugin, and offer a button that simply toggles the plugin-type: plugin field on or off. (This would probably require a save/reload cycle.)

The caveat, though, is that to address these, we’d need to add [all[tiddlers+shadows]] to a lot of filters, including many otherwise simple ones. That might be a real impediment.

We could do something similar without that caveat – but with much more complexity in implementation, probably beyond my own skills, but possible for the experts. We could have a plugin-like JSON file holding the tiddlers we might want to hide. These would be promoted to real tiddlers by some (right now imaginary, even magical) process. When we want to hide this content, another magical process looks for all of these that have not been altered from their original (except for created/modified fields) and removes them… then possibly asks the user, for each modified tiddler, whether to keep or remove it. At any time that initial process can re-run, but won’t overwrite those that have been kept, or again offers the user the choice whether to overwrite the current copy. This has all the benefits of my first suggestion, without the caveat. Its own caveat is that it would be much harder to implement.

Absolutely.

Wait, what?!

Sure, just stab me through the heart, will you?! :grinning_face_with_smiling_eyes:

I use these all the time! I think I do so appropriately, when I want to focus on layout or design, and don’t want any pesky, realistic content to distract from the point.

Of course they don’t belong here, but please warn a man before you slaughter his sacred cows, would you? :wink:

That is a fantastic analogy!

1 Like
#23

I know. He’s really good at those.

@Springer I hope you’re putting virtual pen to virtual paper somewhere more lucrative. Seriously.

#24

In the demo wiki I shared for building “take away wikis” I quickly came to realise an effective solution goes further than prepared editions. There is two areas that make this more complex we just have to face;

  • The curation of diverse resource, tools, components, plugins and editions.
  • Presenting this is a way that supports the equally diverse set of user requirements, depth of experience both code and structured thinking.

This is supported by the Original Topic and the perception it reflects.

Editions or plugins are insufficient on their own to curate the possibilities.

Actually some of my explorations suggest we may be able to achieve this one way or the other already. If we could state the functional requirements I may be able to deliver a solution.

  • I may already have one, such as data plugins.

I have explored similar solutions already and the current plugin mechanism is eminently hackable as in my demo site https://takeaway-wikis.tiddlyhost.com/ see the disabled plugin, sometimes simply disabling the plugin is sufficient, and code can be written to look inside the disabled plugin to extract tiddlers.

But just as I say above to @Springer just help me spell out the requirements I am confident I can deliver. Unfortunately this is a common end point in our community, because we are not too good at collaborating to define robust requirements and end up getting lost “in the weeds”.

One thousand :+1:

In addition to banning “foo bar” and other “content deserts” in documentation;

  • Provide examples that use parameters, fields and variables not just static text.
  • We should have a publicly shared sets of data which can be use by the whole community. eg Ford Family for Genealogy, Periodic Table of elements as I published here https://test-data.tiddlyhost.com/

Another consideration should be what we install to build a wiki, and what we install to design the wiki. For example link to tabs could be essential in a design phase but disabled or removed to simplify/publish a wiki.

  • That is some things are installed to serve a temporary function
  • Do these belong in an edition or not?
3 Likes
#25

In a recent thread I asked for a way to include another namespace in the is[system] test and this proved to be trivial eg $:/ system denotes system tiddlers and &:/ could be added, then all the existing is[system] and !is[system] tests include tiddlers with &:/

  • Perhaps we can do something similar so we do not need to modify [all[tiddlers+shadows]] throughout the wiki, but for example adds and exception to the all
  • or perhaps we can build a way to make “selected” shadow tiddlers look like real tiddlers without editing.
#26

She’s a professor of Philosophy at a highly-regarded liberal arts school (my alma mater!).

I doubt it’s particularly lucrative, but I imagine it’s a job where such skills are well appreciated.

2 Likes
#27

Yes, I was thinking about two plugins I have written, they started simple but now have extra features that another user might find idiosyncratic and prefer the earlier ‘vanilla’ versions, yet these enhancements are vital to me and so are the driving force in the writing of those plugins.

I found myself thinking it would be great if plugins could be written with such perfect granularity and wisdom in structure that they could be easily configured by the end user, almost like selecting candy in a mix-and-match store but I think these are idealistic dreams that would be tough to realize.

I reflected on the number of plugins I tried to work with before I wrote my own and why they didn’t fit me. I then reflected that I endured Windows for decades before migrating to Linux, yet I never moaned that Microsoft didn’t offer me the precise flavour, UI, functionality and granularity that I wanted, I had to learn to use the tools provided and if I did ever moan Microsoft were not listening - what we say we want is usually inline with realistic expectations and so everything changes when people migrate to more flexible platforms like TiddlyWiki or Linux, certainly my expectations have changed as my ability to code and configure have increased.

This leads me to the wonder that however valiantly TW volunteers advance the ‘core’ and strive to maintain a useful ‘vanilla’ core product that many of the people involved with and supporting Tiddlywiki are either hackers by nature or may be on the path to becoming such. :slight_smile: I use the term hacker here to refer to someone who gives up on the conventional tools provided and starts making their own tools.

There will probably always be a slight tension even within the same person wearing both hats - trying to produce a good useful vanilla product yet like dogs let loose from the leash people will tend to produce idiosyncratic and individualistic solutions if they are able and may find it difficult to find balance.

The difficulty is in a crowd working together to somehow migrate the more useful hacker output to a more approachable and generic useful tool kit? Certainly my plugins which started off reasonably vanilla are starting to look like one person’s way of working and that in some ways echoes with my disatisfaction with existing solutions when I was not really able to write my own.

One thing that might be useful is an examination of methods and architecture that might enable plugin writers to offer additional options as modules that can be easily included or ignored with that ease being there for both the user and the code writer. Flexibility and levels of granularity? Perhaps the new conditional functionality (if else etc) will allow writers to offer plugins with a greater level of modularity and flexibility for the end user - conditional includes/transcludes?

4 Likes
#28

Thankyou @etardiff for the suggestions, I’m currently having a good time looking at them :grinning_face_with_smiling_eyes:

You explained my feeling perfectly.

As for PowerSearch, I found it really nice (but I feel like the older version’s ui is more clear for a new user if we want to do something similar, the new one is cleaner but shows little, its potential remains “hidden”)

#29

Totally agree, especially with:

Provide examples that use parameters, fields and variables not just static text.

For me it was very important for my learning of tiddlywiki the possibility of reverse engineer the solutions other users proposed.

Therefore:

I really don’t know if they would be useful. They could complicate things.
BUT I really have to admit that since I installed “link to tabs” I started learning almost twice as fast (I don’t know if it was something that would have happened anyway, but link to tabs allowed me to give vent to my curiosity and therefore I learned a lot.)

Maybe we could do 2 almost identical editions?

  • Standard edition
  • (and more hidden, but still aviable) “With designer tools”

So the user chooses for himself what he wants.
I think the “With designer tools” edition should be harder to find, it should not be presented immediately, perhaps it is hidden after some text (in this way it will be discovered by those who are truly more curious and have more desire to learn and not by the user who wants use TiddlyWiki without complications. Natural selection :joy:)

…a way to make “selected” shadow tiddlers look like real tiddlers without editing.
I advise against it

Precisely because a user learns a lot by studying and playing around with what already exists or with the solutions proposed by other users, making them ambiguous could only create confusion.
There may be a risk that looking at these tiddlers will give you the wrong idea of ​​what constitutes a “shadow tiddler”.

I would do something even simpler: A collection of example tiddlers tagged with “Sample tiddler”. In a tab in the sidebar or somewhere else we have two buttons:
"Delete all sample tiddlers"
"Install sample tiddlers"

The first is self-explanatory, the second is a link to a tiddler package that the user can install as json (or other methods)
Something like that, just an idea

2 Likes
#30

Currently, the https://TiddlyTools.com/#TiddlyTools%2FSearch%2FFilters interface defaults to “hiding” the “Filter Builder” controls inside a popup that can be quickly displayed by pressing the “tools” (hammer and screwdriver) button that appears next to the “Filters” list dropdown button. This was done in order to present a less intimidating interface that works well as a feature-rich replacement for the standard $:/AdvancedSearch > Filter tab while making the “Filter Builder” popup controls just a single click away.

However… one aspect of ALL TiddlyWiki popups is that the visibility of each popup is controlled by a $:/state/popup/... tiddler, which only persists for the current session, and is automatically discarded when the document is saved.

It would be relatively easy for me to change this behavior so that the Filter Builder visibility is stored in a non-volatile $:/state/... tiddler that would be retained when the document is saved. Thus, after the “tools” button is clicked once to display the Filter Builder, and the document is then saved, the Filter Builder controls would be visible by default until manually hidden.

In this way, if the TiddlyTools/Search/Filters were included in a “starter” edition, it could be set to initially show the Filter Builder controls, which may be “more clear for the new user”.

Does this sound like a decent “compromise” solution to you?f

-e

2 Likes
#31

These are interesting reflections. I believe we could start opening a collective project.

Since what we are trying to build is a simple edition, in my opinion it shouldn’t be too complicated (besides, I’m an incurable optimist)
Now I’m talking about “editions” because in my opinion it’s the first step to take: Let’s start with an organic product first, which is also the easiest thing to do. then we will think, if necessary, about making it more “grainy” and flexible. I would say first let’s try to see what direction it would take

Yes, I don’t know how easy it will be, but I’m honestly quite optimistic. What is certain is that we need to build something that encourages customization, but still gives a foundation to build on.

Perhaps rather than “encourage” I should say “allows” customization. I don’t know how to “encourage” custiomization or if encouraging it is the right thing to do. But giving the tools to the user to make it his own is the best thing we can do.

  • In this regard, I share my thoughts on something:

    I have already mentioned that I learned to use TiddlyWiki by deconstructing other users’ solutions, that link to tabs was very useful to me, etc.

    I would encourage, wherever possible, building plugins for a “starter” edition with code readability in mind.
    Sometimes I imagine it is necessary, especially for more ambitious plugins, to use many transclusions and many different tiddlers, but for the user who wants to learn, reading codes that are too branched out is very difficult, and learning opportunities are lost.

    I say this as a complete inexperienced person, it may be a bad habit to try to give priority to the readability of the code. I do not know. So forgive me if I’m wrong. But I wanted to say it, because if it is possible, it can help inexperienced users a lot. (Maybe this should be considered for the most linear and simple functions, for more complicated things, the priorities are different)

I don’t know how we could organize ourselves, I don’t even know the possibilities of this site, but I would say to focus on building a couple of very simple “starter editions” of different categories.

Maybe a “recipe starter edition” and a “note-taking starter edition”. (Idk, just an example)

We could create two topics and two projects: In the topic we collect which functionality we believe could be the best for the purpose of the edition, perhaps also using polls. Maybe we can also share some of our own solutions and discuss whether they can find a place in a “starter edition”.
Then we could start compiling them and we see where these projects take us.
In short, test the waters

1 Like
#32

Yes, that seems like a good idea to me :+1:t2: