[tw] Re: [BETA] - TiddlySpace Backup Scripts

[Chris Dent]

It's really a shame how this shutdown has been handled. I can see from the 
frontpage and tapas that people are still creating new content and new 
accounts on tiddlyspace. I suspect this is because the frontpage was never 
updated to announce the shutdown. It's only once you've created an account 
that you ever hear about the shutdown.

Thank you mario for making sure people have a good way to save their stuff.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/b2f89ea3-f80d-48c7-8673-e45be32a6376%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [BETA] - TiddlySpace Backup Scripts

[Chris Dent]

On Monday, November 14, 2016 at 12:17:51 AM UTC, PMario wrote:
>
> On Sunday, November 13, 2016 at 10:41:10 PM UTC+1, Tobias Beer wrote:
>>
>> Great stuff. Any chance / idea for also grabbing binary files once put up 
>> via:
>>
>> <>
>>
>
> I didn't think about them yet. 
>
> Downloading the stuff should be possible, but how can we "automagically" 
> find them?
> Is there anything we can use to identify them. 
>
>  
 Each tidlder has an attribute named 'type' that, if it has a value is the 
type of tiddler that it is, for example 'image/jpeg'. The fat json that 
your script downloads can be inspected for that. The 'text' attribute 
contains the base64 encoded data that represents the binary. That can be 
decoded. Thus is it possible to go through a fat json tiddlers collection 
and extract all the images to separate file.

I've made a quick python (works for both 2 and 3) script that will do this 
for images: https://gist.github.com/cdent/1254a9c98d8ba316e6c0223f9dd03925

If you run it in the directory where the fat json files are as `python 
extractbin.py *.json` all the image tiddlers will be dumped into a 
directory named 'binaries'.

I hope this is enough to keep people some ideas on how to process the data. 
There are also ways to search tiddlyspace for tiddlers of particular types, 
but since the fat json already includes the data locally processing that 
seems easier.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/3b12fe30-22b0-4088-b314-53bdaf42b60e%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [BETA] - TiddlySpace Backup Scripts

[Chris Dent]

@cdent is there a better search option?
>
>
It's possible to filter the list of recipes with something like:


http://tiddlyspace.com/recipes?select=name:%3Esunyit&select=name:%3Csunyiu 

Basically that's saying get me all the recipes with names between sunyit 
and sunyiu. When someone is logged in it will also return those private 
recipes which the current user is able to see.

There are other filtering incantations that can be done on the recipes list 
as well. There's more information on filters in 
http://tweb-filters.tiddlyspace.com/

Note that I have moving information like that to tank on my do-really-soon 
to do list, so that it doesn't get completely lost.

Your script makes a lot of sense Mario. Not overly complicated but does the 
right stuff. Getting both the fat JSON and the HTML of the tiddlywiki is a 
great way to do it. One thing you might consider is instead of pulling the 
bag tiddlers, get the recipe tiddlers. For people with multiple spaces this 
would result in a great deal of duplicated data but might make 
reconstructing things later a bit easier. Not sure if that's a good idea or 
not, but I though it was worth mentioning.

Thank you for cc'ing me on this and if other things come up where you think 
I can help please cc me again. I don't actively read these or the other 
tiddly groups anymore (due to lack of time, not lack of interest) so I 
don't become aware of stuff unless people let me know directly.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/72903b05-df22-430f-b37b-b99f4146a077%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: TiddlyWiki Usage Statistics

[Chris Dent]

If you're trying to get some sense of diversity of editorial engagement off 
the tiddlyspace stats, the value that is perhaps most useful is the trend 
of the BagsChanged column. BagsChanged is "Count of bags in which at least 
one tiddler was changed today." FatBags tells you how many, at some point 
in their life, had some action. Editors is how many different people 
edited. Created and Modified count tiddlers changed that day.

At one point webalizer was running on tiddlyspace.com but I don't know what 
the URL was, nor if it is still accessible in any fashion.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/3adb3184-c4ea-4110-98f7-2c4cbde42986%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: Running TW5 on TiddlyWeb

[chris . dent]

On Sun, 10 Apr 2016, Robert Kreuzer wrote:


While working on this, I realized that TiddlyWiki itself now also comes
with a simple server-side component using NodeJS.
I was wondering what the differences/advantages of using it are rather than
using TiddlyWeb as the server-side?

It looks to me as if TiddlyWeb has a lot more features but is currently
also quite hard to integrate with TW5.
Are there some fundamental differences that make one more suitable than the
other for a multi-user TW5?


As far as I recall TW5's server doesn't support users (or at least
not multiple users) at all. Nor does it support TiddlyWeb's concept
of policies[1], recipes[2] and filters[3] in any significant way.

Recipes are effectively the reason TiddlyWeb was created in the
first place. Since then things like serializers[5] and plugins[6]
have made it very flexible and capable.

[1] https://tank.peermore.com/tanks/tiddlyweb/policy
[2] https://tank.peermore.com/tanks/tiddlyweb/recipe
[3] http://tweb-filters.tiddlyspace.com/ [4]
[4] The filters content will be moving off tiddlyspace soon.
[5] https://tank.peermore.com/tanks/tiddlyweb/serializer
[6] https://tank.peermore.com/tanks/tiddlyweb/plugins

--
Chris Dent   http://burningchrome.com/
[...]

Re: [tw] Re: Running TW5 on TiddlyWeb

[chris . dent]

On Fri, 25 Mar 2016, Robert Kreuzer wrote:


I have followed your instructions as far as I understood them, but I
unfortunately know too little about tiddlyweb to make sense of everything.


Apologies for not keeping track of this as much as I initially
promised. Without further input from the TW5 experts it can only get
so far and so far we've not really heard from them...


1. created a test instance in tiddlyweb with `twinstance test`
2. Added the tiddlywebplugins.status and tiddlywebplugins.cors plugins to
test/tiddlywebconfig.py ('system_plugins': ['tiddlywebwiki',
'tiddlywebplugins.status', 'tiddlywebplugins.cors'])


You'll also need these settings:

‘cors.enable_non_simple’: True,
‘cors.allow_creds’: True,
‘cors.match_origin’: True,


3. Create a new recipe called 'somerecipe' using: curl -X PUT -H
'Content-Type: application/vnd.tiddlyweb+json' -d
'{"recipe":[["system",""],["common",""]]}'
http://0.0.0.0:8080/recipes/somerecipe


This is right.


Does this make sense so far? If I understand you correctly, I should now
have a $:/config/tiddlyweb/recipe that points to 'somerecipe'.
But I'm not sure where the TW5 files should go in my 'test' instance. And
do I just clone the TW5 repo and copy it in, or is there some other way to
do this?


This is the tricky tw5 part. There are changes necessary to code
within the tw5 repo to make things go. Those changes are shown in
this diff:


https://github.com/Jermolene/TiddlyWiki5/compare/master...cdent:cd/tiddlywebforrealz

Where I've put 'foo' in 'tiddlyweb-recipe.tid' you would put
'somerecipe'.

With those changes in place you can then build a TW5 following the
build instructions available with tidldywiki5.

I'm hoping someone will step up from the tw5 side to provide some
detailed instructions on how to do that and maybe how to most
effectively get the tiddlywebadaptor.js code working properly with
tiddlyweb.

The end goal here is making it possible for a local tiddlywiki html
file to talk to a tiddlyweb server effectively. I've made it work,
quite well, but it requires a lot of hacking into the TiddlyWiki
code (as shown by the diff above).

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/alpine.OSX.2.20.1603301243590.37861%40shine.local.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: Running TW5 on TiddlyWeb

[chris . dent]

On Mon, 14 Mar 2016, Chris Dent wrote:


* Either create a new edition for tiddlywiki5 which could be described as
"standalone access to tiddlyweb", or make the existing tw5tiddlyweb edition
support that use case as well.
* Such as edition would need to account for the changes to
tiddlywebadaptor.js described above. Probably by effectively branching in
the right places based on certain conditions. This is hard for me to do
because I don't know the available contextual variables.


There's a very rough diff of my local tw5 changes here:
https://github.com/Jermolene/TiddlyWiki5/compare/master...cdent:cd/tiddlywebforrealz

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/alpine.OSX.2.20.1603142207230.73610%40shine.home.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Running TW5 on TiddlyWeb

[Chris Dent]

On Monday, March 14, 2016 at 2:26:48 PM UTC, Robert Kreuzer wrote:
>
>
> I would like to run TW5 via TiddlyWeb for a multi-user wiki. I have a 
> running TiddlyWeb instance, but I couldn't find any documentation how to 
> integrate TW5 with it.
> Is there anybody who has done this recently and could point me in the 
> right direction?
>

Thanks for posting here Robert. As I said I would in the issue[1] I've 
started experimenting with this and it is has been more complicated that I 
initially expected, so it is good the thread is started here so we can get 
some input from people more familiar with the tw5 side of things. I'm 
gathering my notes here so people can chime in and we can figure out the 
right solution. Eventually we'll have one.

We didn't talk at the time how you wanted to set things up, there are a few 
options:

1. Run a web server that hosts a tw5 html file that it serves to users, 
alongside the tiddlyweb service. This is a bit like what Tank[2] can do and 
is essentially what tw5 itself does, in server mode.
2. Have editions of tiddlywiki5 which are built to talk to a server where 
the content lives, but are otherwise empty. This mode could allow the same 
bare tiddlywiki5 to talk to lots of different server, based on 
configuration settings.

The editions/tw5tiddlyweb that is in the TiddlyWiki5 code repo is built 
specifically for talking to TiddlySpace, requiring a few features that are 
(custom /status response, custom authentication challenger). Since 
TiddlySpace is dying, this isn't a great solution, so I worked on option 2 
to see what issues are present.

There are a few.

On the tiddlywiki5 side:

* tiddlywebadaptor.js requires /status to provide recipe information. This 
is only done on tiddlyspace, and is extractable from the user's request 
based on the domain they are accessing the service with. On a plain 
TiddlyWeb server you can only know the recipe if it is in the URL. So this 
won't work. In my experiment I modified tiddlywebadaptor.js that will use a 
$:/config/tiddlyweb/recipe tiddler during the build process. It contains 
the name of the recipe (in my case "foo") in which tiddlers are to be 
stored.
* tiddlywebadaptor.js assumes that the wiki will be loaded from http or 
https. If it is not, the adaptor doesn't run at all.

If I create appropriate $:/config/tiddlyweb/host and 
$:/config/tiddlyweb/recipe tiddlers, adjust tiddlywebadaptor.js to use, and 
adjust the adaptor to export itself without checking 
document.location.protocol, then I can produce an edition which will 
communicate appropriately with the tiddlyweb server and recipe described by 
the host and recipe tiddlers.

On the tiddlyweb side:

* Even though it doesn't produce the desired information a /status url 
still needs to return a json object such that tiddlywebadaptor.js will call 
it and then call the subsequent callback (listing the tiddlers on the 
server). This can be done by adding the tiddlywebplugins.status plugin to 
the tiddlywebconfig.py's system_plugins list.
* In order for the browser to communicate to the server via a file: URL 
CORS is required on the server. tiddlywebplugins.cors can provide that.
* The recipe defined $:/config/tiddlyweb/recipe needs to exist before the 
TiddlyWiki looks for it.
* For the time being I've ignored authentication.

Once all that's done, at least in Firefox it all works quite gracefully. 
Load the tiddlywiki, it gets the list of tiddlers from the server, when you 
create a new one it is saved to the server.

So that's at least a starting point. That suggests we need to:

* Effectively document the tiddlyweb-side configuration and running pieces. 
It's not hugely complicated, but it does require installing tiddlyweb plus 
a few plugins and then configuring the instance to use them. I can make a 
cookbook for that and then I reckon someone could probably make a container 
that does it cleanly.

* Either create a new edition for tiddlywiki5 which could be described as 
"standalone access to tiddlyweb", or make the existing tw5tiddlyweb edition 
support that use case as well.
* Such as edition would need to account for the changes to 
tiddlywebadaptor.js described above. Probably by effectively branching in 
the right places based on certain conditions. This is hard for me to do 
because I don't know the available contextual variables.

What do people think?

[1] https://github.com/tiddlyweb/tiddlyweb/issues/105 
[2] https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/565e4eac-4285-4856-b23b-befaba55cbae%40googlegroups.c

[tw] TiddlyWeb documentation migration

[chris . dent]

I've started the process of moving the TiddlyWeb[1] documentation from
TiddlySpace to Tank[2]. This is to account for the expected shutdown
of TiddlySpace, due sometime this year.

I've used totank[3] to do the initial migration. This went well but
leaves a few issues in the content[4] that I will address as time
allows.

The new content now lives at

   https://tank.peermore.com/tanks/tiddlyweb/index

but can also be reached at

   http://docs.tiddlyweb.com/

This latter URL will redirect into tank.

Meanwhile I'm in the process of releasing a new version of TiddlyWeb
that simply updates the documentation refernces to not point to
tiddlyspace.

Let me know if there are any issues or questions.

[4] The primary issue with the content is that it is a mix of
markdown and tiddlywiki classic syntax. Tank only supports the
former within its default wiki page environment. To work around this
in the short term I've forced all the tiddlers which were type
`text/x-tiddlywiki` into `text/x-markdown`. This makes the readable
and presentable by the system, but with some incorrect formatting.
My plan is to correct these as I find them. If you are interested in
helping out, create an account on tank and let me know: I'll grant
you permissions to edit in the tank.

[1] http://tiddlyweb.com/
[2] https://tank.peermore.com/
[3] http://totank.tiddlyspace.com/
--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/alpine.OSX.2.20.1603131713440.69256%40shine.home.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [EOL-TS] Message from TiddlySpace

[chris . dent]

On Tue, 23 Feb 2016, Yakov wrote:


Chris, could you please do the same for the current snapshot of
tiddlyweb.tiddlyspace.com?


I'll be moving the contents of that space to
https://tank.peermore.com/ sometime before the end of the year.
Much of the content in @tiddlyweb is formatted as markdown so
putting it in a tiddlywiki classic won't be of much use.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/alpine.OSX.2.20.1602232217160.3654%40shine.local.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [EOL-TS] Message from TiddlySpace

[chris . dent]

On Mon, 1 Feb 2016, Yakov wrote:


2. EOL of TiddlySpace doesn't mean that tiddlyweb.com is going anywhere,
does it?


tiddlyweb.com is hosted on my personal server and the domain is
owned by Jeremy so that will be sticking around. One issue that will
need to be addressed is that a lot of the tiddlyweb documentation
currently lives on tiddlyspace in http://tiddlyweb.tiddlyspace.com/

I'll probably use totank to deal with that:
http://totank.tiddlyspace.com/

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/alpine.OSX.2.20.1602041230410.5174%40shine.home.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [EOL-TS] Message from TiddlySpace

[chris . dent]

On Thu, 21 Jan 2016, Tobias Beer wrote:


Would you say it makes sense to...


I think what makes sense depends a great deal on who is doing it.
Unfortunately we never really achieved frictionless tiddlyweb.


  - figure out a local install of TiddlyWeb / TiddlyWebWiki
  - somehow replicate / migrate / import spaces there

Right now I'm inclined to simply make local backups of all spaces.
This, of course, will do away with any inclusion and produce standalone
wikis.


I suspect local backups (that include all the stuff that would be
included from other spaces if hosted on tiddlyspace) is probably the
most straightforward way to continue getting individual functionality.

I'm sorry I can't give more concrete advice. I've never really become
all that savvy with TiddlyWiki.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/alpine.OSX.2.20.1601221423430.58599%40shine.local.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [EOL-TS] Message from TiddlySpace

[Chris Dent]

On Sunday, January 17, 2016 at 9:21:25 AM UTC, Mat wrote:
>
>
> People might want to check out TANK  which is 
> created by the lead developer of TiddlyWeb and, previously, TiddlySpace.
>
>
I continue to maintain tank and use it as my daily notetaker. I don't, 
however, pay that much attention to how it is being used with tiddlywiki 
class and tw5. It can be used in that context:

* https://tank.peermore.com/tanks/docs/TiddlyWiki%20Classic
* https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five 

but I suspect there are some issues. Please feel free to try it out and if 
it does not behave make some issues

* https://github.com/cdent/tank/issues

I can't promise that I will attend to them immediately (day job comes 
first).

For people who want to experiment with their existing tiddlyspace content 
on tank there's a space for that:

* http://totank.tiddlyspace.com/

Again, I haven't tested this recently, but as far as I know nothing should 
have changed.

Throughout it all, though, please keep in mind that Tank has a different 
paradigm from TiddlySpace. On the surface it is an old school paged-based 
wiki. Underneath is a tiddler application platform. In that underneath 
layer it is possible to use either version of TiddlyWiki as one of the 
apps. I wrote about the differences between Tank and TiddlySpace last year:

* https://tank.peermore.com/tanks/tank-notes/TiddlySpace%20and%20Tank

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/9f768779-d5b8-44b5-bd28-6ea17455c220%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [EOL-TS] Message from TiddlySpace

[Chris Dent]

On Tuesday, January 12, 2016 at 2:14:14 PM UTC, Mat wrote:
>
>
> I was positively surprised to see it last for as long as it did after 
> @cdent left.
>

I think that's a credit to the work that I and others did to set things up. 
We had a really good group of people doing really good work. That things 
have remained standing for two years with apparently very little input from 
the remains of Osmosoft is quite remarkable.

And, just to be clear, in case there's any confusion: I didn't want to 
leave.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at https://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/ef9d684e-3537-4e94-b082-5884d61d7249%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [TW5] Most basic "Hello World" version of TW?

[Chris Dent]

On Sunday, August 30, 2015 at 10:19:43 PM UTC+1, Ben H. wrote:
>
> Which is what brings me back to my original question, which might be 
> better phrased as "How do I separate the Tiddles from the Wiki?"


If what you're after is tiddlers without the wiki then TiddlyWeb[1] may be 
what you want. It provides an HTTP and Python API for storing and 
manipulating tiddlers in a variety of interesting ways that enables a lot 
of the linking, addressing and including abstractions of hypertext.

It was originally developer to be the "mother of all server sides" for 
TiddlyWiki Classic but it very soon became clear that the way it presented 
tiddlers as first class resources in the system made it very powerful.

I continue to use it as a primary tool for building apps and other tools 
that require linking or transclusion of little bits of stuff.

It has an extensive collection of plugins[2] that let you add functionality 
on lots of different dimensions.

It is the framework that is underneath my current day to day wiki: 
https://tank.peermore.com/

One of the reasons I think it might be useful for you is that when people 
first start using it they often build to do applications or other personal 
information management systems.

[1] http://tiddlyweb.com
[2] 
https://pypi.python.org/pypi?%3Aaction=search&term=tiddlywebplugins&submit=search

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/tiddlywiki/eb9c2684-0262-4e84-8446-8729464ff201%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[tw] TiddlyWeb updated, Tank updated

[chris . dent]

I had a bit of rare spare time today so I:

* release a new version of TiddlyWeb (2.4.1)
* updated Tank with some changes

The changes to TiddlyWeb fix some error messages so they include
more detail on the problem.

The changes to Tank include:

* Updating to the latest version of TiddlyWiki5[1]
* Better handling of encoding errors.

[1] The new version of TiddlyWiki5 is probably of most interest to
the people in the TiddlyWiki group (I'm posting this to both
[tiddlyweb] and [tiddlywiki]). This brings the version of
TiddlyWiki5 on Tank to 5.1.8-prerelease. It appears to be working
okay except that the "Please save and reload to allow changes to
plugins to take effect" keeps showing up.

There's a bit more information (potentially now out of date, please
let me know if it is) on how TiddlyWiki5 works in Tank
here:

https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five

And there's a diff between my version of the tiddlywebadaptor.js for
tank and the one in the main repo here:

https://github.com/Jermolene/TiddlyWiki5/pull/1654/files

--
Chris Dent   http://burningchrome.com/
[...]

[tw] Re: TiddlySpot and/or TiddlySpace???

[Chris Dent]

On Saturday, March 21, 2015 at 12:22:38 AM UTC, Ed wrote:
>
>
> *Quick Update*Looking any further I stumbled on *Tank* and *TiddlyHoster*. 
> Could
> that also be included in the equation. Hope I am not asking too
> much of you "old hands"
>

TiddlyHoster, while still alive and no plans to shut it down, is not being 
actively maintained and updated.

Tank is my daily wiki, so I still take care of it, but I don't actively use 
TW5 myself, so the TW5 features lag a bit. I do try to keep up with 
releases as they happen, but I'm not always timely. 

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [TW5] Plugins SocialCalc + Three.js

[Chris Dent]

It's exciting and interesting to  see the TiddlyWiki and Socialcalc worlds 
intersect. They come from a very similar view of the universe.

On Tuesday, March 17, 2015 at 10:35:06 AM UTC, rboue wrote:
>
> I developped some plugins related to engineering tasks.
> After using them for personal projects i'm glad to share with TiddlyWiki 
> community.
> They are here 
> 
> .
>

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: Using TiddlyWiki with simultaneous multi-user updates on own server

[chris . dent]

On Mon, 2 Mar 2015, Tobias Beer wrote:


I imagined the rationale would be something like that. So, taking a look at
*socialusers* for TiddlyWeb may prove to be the best approach to not start
all from scratch.


Yes, likely.


I take it, *tank *implements its own authentication layer / workflow /
processes / modules / forms, independent from or extending *socialusers*.
So yes, wanting some form of user management sure does not necessarily mean
wanting tank... but only those user-management-components when it comes to
authentication, and possibly registration ...well, basic user management
that works out-of-the-box-ish rather than after develop all of that from
scratch.


tank's auth is a UI on top of
https://github.com/cdent/tiddlywebplugins.oauth and
https://pypi.python.org/pypi/tiddlywebplugins.magicuser

--
Chris Dent   http://burningchrome.com/
[...]

Re: [tw] Re: Using TiddlyWiki with simultaneous multi-user updates on own server

[chris . dent]

On Mon, 2 Mar 2015, Tobias Beer wrote:


Not knowing how "socialuser" works, I think it's a bit of a problem /
challenge to fiddle these things out every time you wish to implement
TiddlyWeb... while sounding simply, user management / authentication /
registration workflows have their challenges that do require some well
designed workflows / components / processes.


Unfortunately this is probably true, in no small part because people
have widely varying preferences for what is appropriate for user
management. For example some people prefer not to use Tank because
it requires one of a google, github or facebook account to log in. I
chose that, however, so that Tank has _zero_ knowledge of (or even
interaction with) a user's password.

One reason user management workflows aren't built into TiddlyWeb is
because one size won't fit all.

--
Chris Dent   http://burningchrome.com/
[...]

Re: [tw] Re: Using TiddlyWiki with simultaneous multi-user updates on own server

[chris . dent]

On Mon, 2 Mar 2015, Tobias Beer wrote:


If that signal is lit, then woot, I'll watch closely.


Totally understand. So, let's wait and see some more when attempted
implementation(s) start trickling down.


It's probably not the most productive strategy but time being what it
is...


A cross-server implementation would surely play along the theme of
TiddlyWiki being a "guerilla wiki"... dynamically pulling stuff, even
ad-hoc. Switching that "wiki view" from one recipe / remote content pool to
another. Some remote recipes / bags could be used conjointly: a home /
setup bag, some template foo, a libarary bar, an app baz ...and then others
loaded dynamically / switched to, e.g. "TiddlyWiki plugin repo"...
alongside ways of moving and merging things from remote location A to B.


Yes, this is very in line with the vision of TiddlyWiki/TiddlyWeb
interaction that I've always been shooting for. Your additional
descriptions are very good.


Mario mentioned that managing recipes, bags, even users may not entirely be
in the scope of the TiddlyWeb API. Is that so or what aspect(s) of a
TiddlyWeb setup can be managed via HTTP(s), if any? Otherwise, how do you
envision a meaningful default workflow so as to get a TiddlyWeb instance up
and running in a multi-user environment?


The _API_ supports managing recipes, bags and policies for both,
directly in the TiddlyWeb core. There's a plugin,
tiddylwebplugins.socialusers, which adds _API_ support for users.
What's not present is client side tooling (libraries, UIs) for
managing the operations.

I think there's a perception that doing CRUD on recipes, bags and
users in TiddlyWeb is quite complex. What's complex is effectively
implementing the concepts. The actual operations are simple PUT
requests with a relatively small amount of JSON[1].

One a tiddlyweb instance is created, installed and configured (with
the socialusers plugin), it is possible to manage all the necessary
operations over the API.

(You might be wondering why the socialusers plugin is a plugin rather
than built it. Basically it is because it requires an explicit step
for the admin of the service to say "Yes, I want to expose user
management over the web.")


I see, so again it's a task that begs for someone to start playing with a
TiddlyWeb server and test out certain communication patterns as to how
suitable they are to implement polling in a collaborative environment and
then properly handle (merge) conflicts, mostly.


Seems so. I think that's the general truth: people just need to try
stuff and see where it goes. There's a tendency to want to solve
problems before they are concrete.

[1] A good starting point for the API is here
http://tiddlyweb.tiddlyspace.com/HTTP%20API or here
http://tiddlyweb.tiddlyspace.com/explorer
--
Chris Dent   http://burningchrome.com/
[...]

Re: [tw] Re: Using TiddlyWiki with simultaneous multi-user updates on own server

[chris . dent]

On Fri, 20 Feb 2015, Tobias Beer wrote:


However, while you may not be equiped with the time-resources to do it all
yourself, I think you could perhaps keep an eye on vision /
implementation... being the most knowledgeable on the perhaps more critical
TiddlyWeb end. Let's face it, who else really has the background to guide
through that process? So, do you think it would be possible for you to open
up some TiddlyWeb5 repo to which other's could make pull request where you,
however, would be sketching out the basic issues, lead the conversation so
to speak, where you are able, and possibly throw in the occasional doodle
of the details of any of this...


I'm happy to advise and support people, and do try to keep track of
anything that has some relevant to TiddlyWeb. However I don't want to
be in the position of initiating a repo as someone else doing so is a
clear sign of real commitment by someone or some group. I think it
would be a bad idea to remove that signal.

If that signal is lit, then woot, I'll watch closely.


* is designed to work with TiddlySpace rather than a generic TiddlyWeb

server


You see, there are only a few people who really understand what that means
precisely.


Which is interesting because I didn't write the tiddlyweb adaptor for
TiddlyWiki 5.

It's effectively this line that is the issue:

https://github.com/Jermolene/TiddlyWiki5/blame/3df341621d30b205775288e324cef137c48e9f6e/plugins/tiddlywiki/tiddlyweb/tiddlywebadaptor.js#L68

That is the only place that the recipe for the adaptor is set but it
uses a piece of data that only exists on TiddlySpace. As I've
described here:

https://groups.google.com/d/msg/tiddlyweb/UcYrnvGwNUQ/UJRgSn4VjfYJ

the recipe can be set manually but it would better if TiddlyWiki5
could ask the user what recipe on what server they want to use and
load that into a story (either including it in the current, replace
the current or making a namespaced one adjacent to the current).


I take it, you mean to expose the available recipe's on the TiddlyWeb end
and then assign them in the TW5 front-end. I guess, the point to start is
that TiddlyWeb API for anyone to retrieve recipes or perhaps just bags, for
starters.


Pretty much, yeah.


There are some smarts in TiddlySpace that could be referenced at some
"action-item" so that there would be at least something to start looking
for solutions other than a blank canvas.


True. There are (as with everything) simple and deluxe ways to handle
things. The easiest thing to do is to respond to the HTTP response
code for an edit conflict with a warning message to the user. Then
they can choose to resolve it however they like.


That is fine, so long as the setup is doable on the server-side. At some
point there may be some TW5 Admin console to some TiddlyWeb backend, but
let's just start with the basics of getting collaboration up and running...
with requirements as to some srver-smarts in terms of setting things like
recipes and bags up properly.


The direction I'm trying to push things is that as much smarts as
possible are in TiddlyWiki. This is possible. The APIs exist such that
a very minimal tiddlyweb server can do most of the things people have
been wanting.


* content change notifications either through websockets or fairly

efficient support for being polled for "all changes since last time I
checked"


Not precisely sure what that means in terms of what TiddlyWeb actually
provides in terms of an API and how the communication details sort out.
Again, I would think there is some codebase on the TWc end in TiddlySpace,
isn't there?


Yes, I suspect so, but it really comes down (if not using the
websockets option) of frequently asking the server for info at the
right url:

  https://tank.peermore.com/bags/cdent/tiddlers?select=modified:%3E2015

(anything in that bag since the beginning of the year)

Those selects work on any tiddler collection. There are also ways to
do it with searches.

--
Chris Dent   http://burningchrome.com/
[...]

[tw] Re: Using TiddlyWiki with simultaneous multi-user updates on own server

[Chris Dent]

It's not possible to do easily, yet, so I'm not suggesting the following as 
a solution. In addition your posting reads like you are looking for 
something where the server is just for storage and little more than that.

Instead I'm just making my semi-regular "with a bit more work this could be 
done with TiddlyWeb" posting. Implicit in this should be read my apologies 
for not being able to do it myself due to employment constraints.

TiddlyWiki 5 and TiddlyWeb can talk to one another relatively well, but 
with some issues that could be fixed.

The existing (last time I checked) tiddlywebadaptor plugin:

* is designed to work with TiddlySpace rather than a generic TiddlyWeb 
server.
* it's difficult to make it dynamically choose a desired recipe to use as a 
source for content.
* it doesn't have smarts for how to fruitfully deal with edit conflicts 
(TiddlyWeb will return a response code indicating when one happens)

TiddlyWeb can provide (given correct setup) but doesn't make it easy enough:

* content change notifications either through websockets or fairly 
efficient support for being polled for "all changes since last time I 
checked"
* comprehensive authentication (are you who you say you are) and 
authorization (can you access this thing to do action X) controls via 
challengers and polices
* scales from little personal installations to huge enterprisey 
installations

If anybody wants to know more about these issues or features please ask and 
I can try to provide more info.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [TW5] Which plugin to see Motovun Jack.pdf ?

[chris . dent]

On Thu, 22 Jan 2015, Tobias Beer wrote:


might not even be needed if TiddlyWiki itself does the cross referencing
when talking to a number of TiddlyWeb servers


Yes, exactly the point I was trending towards.


one question is, at what point would a TiddlyWeb
go talk to remote bags if not through user interaction?


In the current implementation it is only through a user agent
(generally prompted by some kind of click) leading to a request for
a tiddler in a remote bag. That could indeed be driving by polling,
events, or anything else, as you say.

But again, I think doing in TW5 would be more flexible and powerful.


There are two ways to approach this...

  1. have TiddlyWeb do the *remotebag* talky-talky


Fun for interesting tricks[1] but not ideal.


  2. have TiddlyWiki talk to a number of TiddlyWeb instances
  and cross reference the tiddlers in some way,
  e.g. via fields that read like...
 - *reply-to*: http://unique.com#origin
 - *reply-to*:
 http://unique.com/tweb/bags/{bag_name}/tiddlers/{tiddler_title}


Yes, something like that.


It doesn't strictly have to be file-based even.


(What I'm meaning here is that you can do the fun with TW5 when the
wiki is loaded from file: or http:, not file-based as in data being
stored in files.)


Yes, I take it that there are db adaptors for TiddlyWeb.
So, storing tiddlers in bags and defining recipes does not require a purely
file-based storage.
TiddlyWeb decides on how to pull the tiddlers and from where,
so all you need is to properly address the api, the rest is under the hood.


Yes.


I really think the syncer module(s) should allow multiple instances talking
to distinctly configured stores... with appropriate conflict handling, i.e.
store that content in some unique namespace where it doesn't conflict with
the "locally owned" tiddlers, e.g.


That makes sense.


The above would eventually hold a tiddler name at the very end. Some filter
could extract all remote tiddlers that have the same name as a local one
and appropriately show a conditional button in the toolbar which opens a
popup containing a list of remote tiddlers ...when opened, a custom
ViewTemplate shows this tiddler, but without all the $:/remote/foo...
rather showing a clean Tiddler ui that hides the ugly title and clearly
indicates that this tiddler came from someplace else, while pointing there.


This too.


Anyhow, ownership seems to be the key in what needs configuration within
TiddlyWiki, i.e.

  - "Am I the owner of the content from a given remote server configuration
  ?"
 - *yes*: ok, I can fully CRUD — so long as the server allows me to
 - *no*: I can only read and duplicate into whatever is my own local
 store


If you have a look at the JSON representation for a tiddler produced
by TiddlyWeb it has a permissions attribute that says what the
current user can do to the current tiddler. See:

   http://tiddlyweb.tiddlyspace.com/HomePage.json

for an example. For me it says:

   "permissions": ["read", "write", "create", "delete"]

That's there pretty much for the reasons you're describing.

[1] "remotebag" is a subclass of a concept in TiddlyWeb called
"specialbag" which was created to allow pretty much anything to be
transformed into tiddler in a bag. It provides the interface that
allow some thing to be presented as a list of tiddlers, and some
(other) thing within that thing to be presented as a single tiddler.
Examples included atom feeds, tweets, text files on disk, etc.
--
Chris Dent   http://burningchrome.com/
[...]

[tw] Re: [TW5] Which plugin to see Motovun Jack.pdf ?

[Chris Dent]

On Wednesday, January 21, 2015 at 11:32:57 PM UTC, Mat wrote:
>
> Tobias Beer wrote:
>
>>
>>- we need a tiddlyweb like store
>>
>> But that's not really federated, is it? 
>

TiddlyWeb itself does not have federation built in and it is not a concept 
built into the default API, but here are some thoughts which may be of use:

* There's a plugin[1] that implements a concept known as remotebag[2] which 
probably fits in here somewhere.
* Federation is something happens as a result of an aggregation of servers 
and clients that are aware of each others existence. That awareness is the 
problem which needs to be solved/managed.
* A file:// based TW5 configured with awareness of multiple TiddlyWeb 
servers[3] (or one TiddlyWeb server that holds knowledge of multiple 
TiddlyWeb servers) could self-configure to talk to those multiple servers 
and dynamically use content from them. It doesn't strictly have to be 
file-based even.

I've experimented with this latter idea a little bit with only one 
server[4]. I think TW5 would need some adjustments to cleanly do this with 
multiple servers but I can't see any huge technical barriers to it 
happening. Content is relatively easy, plugin loading less so.

I agree that once it becomes straightforward to take an existing TW5 and 
make it talk to arbitrary places on the network some very interesting 
things will be possible.

[1] https://pypi.python.org/pypi/tiddlywebplugins.remotebag
[2] http://cdent.tiddlyspace.com/remotebag
[3] That are CORS-enabled
[4] https://groups.google.com/d/msg/tiddlyweb/UcYrnvGwNUQ/UJRgSn4VjfYJ

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [TW5] swarms of tiddlers

[Chris Dent]

On Thursday, December 11, 2014 at 10:49:27 AM UTC, Chris Dent wrote:
>
> Properly functioning CORS support was a bit of a struggle to get 
> right, but it goes a very long way to making it possible to build 
> things _elsewhere_ that happen to use tiddlers that are kept in tank. 
>
>
I thought I should annotate this posting with a link to instructions I left 
in the TiddlyWeb group about how to set up a simple TiddlyWeb server 
configured with cors to work with a file-based 
TW5: https://groups.google.com/d/msg/tiddlyweb/UcYrnvGwNUQ/UJRgSn4VjfYJ

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [TW5] YoutubePlugin (tentative)

[Chris Dent]

On Saturday, January 10, 2015 at 4:38:47 PM UTC, Jeremy Ruston wrote:
>
> On Sat, Jan 10, 2015 at 4:16 PM, Astrid Elocson  > wrote:
>
>> Incidentally, why does "_canonical_uri" start with an underscore when 
>> none of the other core field names do?
>>
>
> The name "_canonical_uri" was established by TiddlyWeb, and adopted by TW5 
> for compatibility. I agree that it's unfortunate that it belongs to a 
> different naming style than we usually use.
>

Just for historical reference the name chosen was up for discussion for a 
long time (on tiddlyspace, in the tiddlyweb google group, on github, etc). 
There's various links from here: http://cdent.tiddlyspace.com/20121221

Here's a canonical_uri tiddler as JSON, for 
reference: https://tank.peermore.com/bags/cdent/tiddlers/purplechurch2.png.json

The reason for not using 'uri' is because that was already being used for 
the uri of the tiddler itself. The reason for the leading _ is because in 
TiddlyWeb there are core attributes on the tiddlers (bag, type, text etc) 
and then there is another attribute called fields which contains a custom 
dictionary of additional fields on the tiddlers. Canonical uri was  made a 
field (rather than core attribute) because it is optional (that is, not 
critical to TiddlyWeb's definition of a tiddler) and the leading '_' was 
used to indicate that it was system-oriented rather than user-oriented (a 
 convention borrowed from private variable indications in Python).

The existence of _canonical_uri was expressly for the purpose of allowing a 
single tiddler to act as what amounts to a proxy for a resource that exists 
elsewhere on the web. Thus, in the context of tiddlers you could refer to 
that other resource by its TiddlerTitle while still using it from its 
original place. A side effect was that you could keep tags and other 
metadata about the remote resource in the tiddler that points to the remote 
thing.

The feature is used quite a bit in Tank for handling images and other 
content that can be dragged and dropped into a wiki. The actual binary 
content is saved in S3 and a _canonical_uri tiddler created to point to it. 
I mostly did it to save on disk space, but it also means that bags that 
appear to contain binary tiddlers are not slowed down by the binary 
tiddlers.

If the name is unsightly within TW5, why not change it, and just do a 
translation in tiddlywebadaptor.js? It already has to do that to deal with 
TW5's non-nested handling of attributes+fields.

I hope that bit of info is of some use for people who might be curious.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [TW5] swarms of tiddlers

[chris . dent]

On Wed, 10 Dec 2014, Mat wrote:


Probably not a coincidence - I have most likely been influenced by blog
posts of yours, and specifically remember reading about your fascination
with the individual tiddler rather than the whole TW. BTW how would you say
your TANK <https://tank.peermore.com/> project manifests this vision? (I am
not a member there).


On the surface Tank is mostly just trying to be a simple page-oriented
wiki but it has a few features (beyond those already provided by
straight TiddlyWeb) with which it tries to make the swarms of individual
and collections of tiddlers a bit more available:

* The auth model + full CORS support makes it fairly straightforward
  for other interfaces and web services to do CRUD operations on
  tiddlers. You can create named revokable keys which you can "give"
  to various applications or tools.

* There is a thing call the policy manager[1] which makes it easier to
  adjust the policy settings on individual bags so that you can easily
  say what users can do what actions on the bags. Support for recipes
  is pending.

* Tiddlers are easy to move between tanks.

* Compositions[2] make adding additional functionality (both simple[3]
  and complex[4]) a matter of putting the right things in the right
  place.

* Like tiddlyspace there are websocket notifications and atom feeds of
  most everything, so other systems can be easily made aware when
  stuff happens.

Properly functioning CORS support was a bit of a struggle to get
right, but it goes a very long way to making it possible to build
things _elsewhere_ that happen to use tiddlers that are kept in tank.

The features list is worth gazing at:
https://tank.peermore.com/tanks/docs/Features

[1] https://tank.peermore.com/tanks/docs/Policy%20Manager

[2] https://tank.peermore.com/tanks/docs/composition

[3] https://tank.peermore.com/tanks/journalizer/index
https://tank.peermore.com/tanks/bookmarker/index

[4] https://tank.peermore.com/tanks/tw5/index

--
Chris Dent   http://burningchrome.com/
[...]

[tw] Re: [TW5] swarms of tiddlers

[Chris Dent]

On Monday, December 8, 2014 11:32:36 AM UTC, Mat wrote:
>
> Tiddlers on the loose, swarming around everywhere.
>

This is pretty much exactly the metaphor that I've been hoping the 
TiddlyWeb API I would enable. 

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: Announcing TiddlyWiki 5.0.15-beta

[chris . dent]

On Tue, 26 Aug 2014, Danielo Rodríguez wrote:


Good to know. How do you want to get the problem reports? Do you have any
specific tank group?


There's a tiddlyweb group[1] and a github repo with issues for tank[2].
For something that is specifically a bug in tank, the github issues
is the way to go.


From tank itself, on the bottom of a lot pages is an "Issues" link

which goes to the github issues page.

[1] https://groups.google.com/forum/#!forum/tiddlyweb
[2] https://github.com/cdent/tank/issues



El martes, 26 de agosto de 2014 11:36:15 UTC+2, Chris Dent escribió:


On Tuesday, August 26, 2014 9:12:45 AM UTC+1, Danielo Rodríguez wrote:


I just registered into your tank application.

Do you have plans to make it work with some offline apps or it will be
100% online?



As things currently stand, from a technology standpoint there's nothing
stopping Tank from working with fully offline apps or with apps that are
offline just some of the time. The HTTP API[1] in Tank is the TiddlyWeb API
so can work well with anything that can do GET and PUT. CORS is supported
so the usual problems with cross-domain situations aren't a problem.

Anyone who is registered with Tank can create new compositions[2]. These
are a way of packaging up functionality (such as TW5) to work with a
collection of tiddlers. The functionality can be pretty much anything.
Existing functionality includes: tw5, twc, a bookmarking system and a
journalling tool.

[1] https://tank.peermore.com/tanks/docs/API
[2] https://tank.peermore.com/tanks/docs/composition






--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Announcing TiddlyWiki 5.0.15-beta

[Chris Dent]

On Tuesday, August 26, 2014 9:12:45 AM UTC+1, Danielo Rodríguez wrote:
>
> I just registered into your tank application.
>
> Do you have plans to make it work with some offline apps or it will be 
> 100% online?
>

As things currently stand, from a technology standpoint there's nothing 
stopping Tank from working with fully offline apps or with apps that are 
offline just some of the time. The HTTP API[1] in Tank is the TiddlyWeb API 
so can work well with anything that can do GET and PUT. CORS is supported 
so the usual problems with cross-domain situations aren't a problem.

Anyone who is registered with Tank can create new compositions[2]. These 
are a way of packaging up functionality (such as TW5) to work with a 
collection of tiddlers. The functionality can be pretty much anything. 
Existing functionality includes: tw5, twc, a bookmarking system and a 
journalling tool.

[1] https://tank.peermore.com/tanks/docs/API
[2] https://tank.peermore.com/tanks/docs/composition

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Announcing TiddlyWiki 5.0.15-beta

[Chris Dent]

On Wednesday, August 20, 2014 11:47:00 PM UTC+1, Jeremy Ruston wrote:
>
> I'm pleased to announce the release of TiddlyWiki 5.0.15-beta:
>

I've incorporated this release into the latest version of Tank:

https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five 

If you use it please let me know if there are problems by reporting an 
issue at https://github.com/cdent/tank/issues

Thanks.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: TW5 on Tiddlyspot, how? ...and dare I utter nodejs?

[Chris Dent]

On Tuesday, July 22, 2014 11:51:43 PM UTC+1, Alberto Molina wrote:
>
> Hi Mat,
>
> 1) Are there more alternatives than Tiddlyspot for this (disregarding a 
>> server of my own)? Tiddlyspot is fantastic, I'm just asking to know if 
>> there exist other options.
>>
>
> I don't know for sure, but I think there aren't atm. TiddlyWeb 
>  doesn't work with tw5, as far as I know (but I 
> never tried). And Tank  is under development 
> (maybe it works already, I didn't try).
>

TiddlyWeb can be made to work with tw5, but it is a bit effortful: you need 
a particular build of tw5. However once you have that, it is pretty much 
just a matter of point the tw5 at the right place.

Tank works relatively okay with tw5:

* https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five
* https://tank.peermore.com/comps/cjdtw5 (you should be able to add 
tiddlers there as GUEST)


-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: TW in Education

[Chris Dent]

I've got some comments on your "ultimate goal" down below, but I wanted to 
respond to some of the earlier things as well, first.

On Saturday, July 19, 2014 2:58:41 PM UTC+1, Måns wrote:

>
> I still use some of my wikis as ressources, materials etc... - I don't 
> want to make my students or collegues sign up for an infrastructure they 
> don't understand or need   - and I lost faith in the sustainability of 
> tiddlyspace (development and support) when Chris Dent stopped working at 
> BT. 
>

I reckon there's enough water under the bridge now where I can say: I 
didn't want to stop working at BT, BT decided they wanted to stop paying 
me. It's still unclear what their plans are (since nobody is talking) but 
they have successfully done the migration to new hardware, monitored by 
someone who appears invested and interested, so I guess things will carry 
on in some form of support. The concern I would have is whether there will 
be any active development.
 

> Tank seems very promising - and I'm sure that Chris will take it far - 
> again it is a project in heavy development and I don't have the needed time 
> or ressources to setup my own Tank on shared ressources at our school atm. 
> On the other hand I'm sure Chris would help me out if I invested some time 
> in a local project with Tank.
>

I'm using Tank every day now as my personal notebook, bookmarker and as an 
archive of my tweets. It basically works for those aspects, but you're 
right, it isn't yet complete (especially on the tiddlywiki sides). I am, 
however, making some progress on making it a bit easier for people to 
install their own tanks: https://github.com/cdent/tankdock But, again, will 
be some time before that is point and click.
 

> Collaboration isn't really the ultimate goal here - it's more simultaneity 
> and syncronicity I'm striving for.
>

This may be a large contributor to why TiddlyWeb, TiddlySpace and Tank have 
never felt, to you, like quite the right fit. All of those are either 
primarily or significantly built by me and _a_synchronous collaboration is 
the driving force behind pretty much all that I create. There are two main 
reasons for that:

* I want to enable work teams that are disjunct in both time and space.
* I want the resources that are created to be available to anyone, 
anywhere, anytime (that is, the fruits of the labor of creating the 
artifacts should be available to the widest audience).

That doesn't exclude the classroom setting, of course, but does 
de-emphasize the simultaneity aspects quite a bit.

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Hosted TiddlyWiki advice.

[Chris Dent]

Andrew (and anyone else),

You might be interested in this thread over in the tiddlyweb group:

https://groups.google.com/d/topic/tiddlyweb/SjuQXdXb5ts/discussion

It's about getting Tank running in Docker. I've made some pretty good 
progress. The remaining issues are labo[u]r and sweat, not conceptual so I 
have pretty high confidence that it is going to be workable. You might take 
a look to see if it might be a good starting point for you.

Or just straight to the github repo: https://github.com/cdent/tankdock

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: Hosted TiddlyWiki advice.

[chris . dent]

On Thu, 10 Jul 2014, 9600 wrote:

On Wednesday, 9 July 2014 14:05:53 UTC+1, Chris Dent wrote:

Small scale manufacturing sounds very steampunk to me! ;)


Hah! Hoping to get a discount on a top hat festooned with brass cogs, eh?


Only if I can get a free monocle with that?


I think I'd like to try setting up Tank.

oauth2 dependency sounds fine for now and I'm guessing other auth methods
could be added later if need, e.g. local password db. Although I wouldn't
fancy having to set up S3. Could a simple filesystem store, or even Git
repo, be configured?


The binary tiddler handling is in the module
tiddlywebplugins.tank.closet. In the git history of that module is
simple implementation that just uses the filesystem (instead of S3),
it ought to be possible to merge that back in as a configurable
thing. That would be an _extremely_ useful patch if you're up for
it?

The tiddlywebplugins.oauth package is not released to pypi yet, so
you'll need to get your own version from GitHub:

https://github.com/cdent/tiddlywebplugins.oauth

and then register an app with an oauth2 provider and set the
relevant config.

You'll probably want to disable 'text/x-tiddlywiki': 
'tiddlywebplugins.twikified'
in the render_map in tiddlywebplugins.tank.config.

There's an optional thing called twsock which provides websocket
notifications of recent changes. That's nodejs-based and requires
some finagling to get set up. I'd suggest leaving that to later if
possible.

One reasonable way to get started might be to checkout the code:

https://github.com/cdent/tank

and try running the tests. It will fail at first, but will reveal
which dependencies you don't have, etc..

Stepwise you'll get there eventually.

A different option is that I do the work to make a docker container
with tank in it. I want to do this anyway, but I haven't had time
yet. With sufficient oomph and push I might be able to get to it.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Hosted TiddlyWiki advice.

[Chris Dent]

On Wednesday, July 9, 2014 11:47:52 AM UTC+1, 9600 wrote:
>
> I'd like to set up multi-user TiddlyWiki hosting on my own server and 
> would appreciate some advice as to which route I should take. This will be 
> mainly for organising my own stuff, but I'd also like the ability to create 
> additional "secure" wiki instances for customers/projects. I quite fancy 
> using TiddlyWiki 5, and beyond straightforward wikis there is the 
> possibility that I might want to create simple apps, e.g. for managing 
> small scale manufacturing, tracking inventory and tasks etc.
>

Small scale manufacturing sounds very steampunk to me! ;)

If you want to use TW5 then tiddlywebwiki won't do the trick, it produces 
TWC. Not only that, but it is also getting a bit behind the curve on the 
best ways to manage content (the new ways are more dynamic with more effort 
on the client side) and it no longer has built in support for server-side 
rendering (the WikklyText package on which server-side rendering depended 
is no longer being maintained) which impacts the quality of Atom feeds and 
search results.

With a bit of work it is relatively straightforward to use TW5 with just 
TiddlyWeb. You need to create appropriate recipes and use the tank edition 
of tw5 (which has the tiddlywebadaptor built in) but otherwise it ought to 
"just work". What you would get by using Tank is more effective policy 
management, friendlier UI, etc. However that comes at the cost of their 
being some currently built in dependencies that you might not want in your 
own installation: auth via oath2 to github, facebook or google; storage of 
binary tiddlers in S3. Both of these things could be made optional, but are 
not currently.

There's a lot of stuff in the way Tank is put together, especially under 
the covers, that I guess would be considered state of TiddlyWeb art. On the 
surface it looks like a nice little markdown-based wiki but there's a good 
deal more going on.

I'm happy to provide help/input in assembling whatever bits and pieces turn 
out to be right for you.

Yours in unicorns, rainbows and colo[u]red dreadlocks

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] tank now has tw5 5.0.14-prerelease

[chris . dent]

I've just updated the tank code and https://tank.peermore.com so that
it uses TW5 5.0.14-prerelease for compositions based on TW5.

If you have no idea what any of that means have a look at:

   https://tank.peermore.com/tanks/docs/Features

And if you have any questions feel free to ask me.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: TW5: Struggling to get started with TiddlyWeb + TW5

[Chris Dent]

Tank[1] has support for TW5[2] but if you don't want to be using the tank 
service it ought to be possible to use the same ideas in your own TiddlyWeb 
installation. Those ideas are:

* I have a fork of TiddlyWiki5[3] that create a tw5 that makes it look in 
the current recipe for tiddlers to load lazily.
* In that recipe there's a tiddler called 'app' which is a text/html 
file[4] containing the special tw5.
* Other bags in the recipe contain tiddlers that provide the content for 
your wiki.

At the moment the tw5 in that fork (and thus in tank) is a couple of 
versions behind the current release. I should be able to resolve that soon.

[1] https://tank.peermore.com/
[2] https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five
[3] https://github.com/cdent/TiddlyWiki5
[4] https://github.com/cdent/tank/blob/master/src/tw5/app.tid

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Tiddlywiki Users Gathering / Conference?

[Chris Dent]

On Wednesday, April 23, 2014 2:53:43 PM UTC+1, stevesuny wrote:
>
> Anyone interested? If I get 3-4 responses here, I'll initiate a broader 
> discussion when we can start talking about timing and location. One 
> motivating factor for me: a looming deadline for small-grant submission 
> (May 15) that I'd hope to use to fund my participation & travel. 
>

I'd be interested but like many I suspect that travel and scheduling could 
be an issue.

I do, however, think that for this sort of thing face to face has some 
advantages. Basically if the point is to have voiced conversations and 
interactions, then in person wins over video etc. 

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

Re: [tw] Re: [TWC] Bullet proof way to publish a TW based application

[chris . dent]

On Wed, 26 Mar 2014, HansWobbe wrote:


Am I correct in assuming that Tank is dependent upon TiddlyWeb?  If so,
might it be possible to build on Tank's capabilities, in conjunction with
TW5 and TWC, to achieve an effective solution.  My interest is simply that
I do not have python resources at my disposal and relatively limited server
admin resources.  Hence I would prefer to "subscribe" to Tank.


Yes, Tank is built on TiddlyWeb + a bunch of server side plugins.

It would probably be possible to use it to get the desired combination
of functionality. The reason I didn't mention it directly before is
because of this requirement in the original message:


Drawback is that if the user chooses a feed he can't see the version
of the local installed tiddler compared to the version on the remote
TW and in the list of importable tiddlers.


I didn't quite understand what that meant and how that might fit in
the Tank view of the world.

However, in my experience, with sufficient use of JavaScript and
familiarity with the TiddlyWeb API[1] it is generally possible to do
pretty much anything[2]. The crucial ingredient is effectively decomposing
"anything" into lots of little tasks involving tiddlers.

(For those that don't know, Tank is (yet another) tiddler hosting service:
https://tank.peermore.com )

[1] http://tiddlyweb.tiddlyspace.com/HTTP%20API

[2] This is now even more true with Tank, because Tank just got
support (yesterday) for CORS
(http://en.wikipedia.org/wiki/Cross-origin_resource_sharing) which
makes the resources stored on Tank more accessible.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: [TWC] Bullet proof way to publish a TW based application

[Chris Dent]

On Tuesday, March 25, 2014 10:07:40 PM UTC, Reto wrote:
>
> I am struggling to find a way to publish my TiddlyWiki based application 
> (means: a TWC containing third party plugins, a self written plugin, macros 
> und other necessary tiddlers > basically a bunch of tiddlers working 
> together).
>

If you're able to do your own hosting, you might consider using TiddlyWeb 
(the code underneath TiddlySpace) with your own set of plugins to get it 
configured as you like. The TiddlyWeb homepage links to lots more info: 
http://tiddlyweb.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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.

[tw] Re: Announcing TiddlyWiki 5.0.8-beta

[Chris Dent]

On Friday, February 28, 2014 4:07:04 PM UTC, Jeremy Ruston wrote:
>
> TiddlyWiki 5.0.8-beta has just been released at:
>
> http://tiddlywiki.com/
>

I've just done the jiggery pokery to get this version included in tank. 
Seems to work correctly.

For those that don't know, tank[1] is yet another hosting solution for 
tiddlers based on TiddlyWeb[2]. It has support for both TiddlyWiki 
Classic[3] and TiddlyWiki 5[4] through a concept called comps[5] and also 
provides a transclusion enabled tiddler and markdown based wiki system. 
There's a list of features on the site[6]. People have asked me what the 
difference is between it and TiddlySpace, so that's written up too[7].

Like TiddlyWiki 5, it's under active development and could charitable be 
called "in beta". The way it uses TiddlyWiki (especially classic) is quite 
different from how it is used in Hoster, TiddlySpace and TiddlyWebWiki so 
could do with some active testing. Feedback very desired and welcomed.

If you try it out, please let me know how it goes.

Thanks!

[1] https://tank.peermore.com/
[2] http://tiddlyweb.com/
[3] https://tank.peermore.com/tanks/docs/TiddlyWiki%20Classic
[4] https://tank.peermore.com/tanks/docs/TiddlyWiki%20Five
[5] https://tank.peermore.com/tanks/docs/composition
[6] https://tank.peermore.com/tanks/docs/Features
[7] https://tank.peermore.com/tanks/tank-notes/TiddlySpace%20and%20Tank

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: [tiddlyweb] Re: RFC: tiddlywebwiki and wikklytext

[chris . dent]

On Mon, 24 Feb 2014, PMario wrote:


On Monday, February 24, 2014 4:26:19 PM UTC+1, cdent wrote:


The default option as this stage, barring convincing feedback in
some other direction, is 2.

Please let me know your thoughts. If you have questions please do
not hesitate to ask.



Your arguments are clear to me. So +1 for option 2


Thanks for your response. It's good to get at least one :)

I've release a 0.69 version of tiddlywebwiki with the proposed
changes.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] RFC: tiddlywebwiki and wikklytext

[chris . dent]

Sorry for the crosspost but I wanted to reach a relatively large
audience with this post. There's an issue on which I need some
feedback.

Since very early on the TiddlyWiki (Classic)-hosting aspects of
TiddlyWeb[1] have been maintained in a project called tiddlywebwiki[2].
This provides a variety of features beyond the standard TiddlyWeb HTTP
API[3], but the two main ones are:

* Retrieving a collection of tiddlers stored on the server as a
  TiddlyWiki with the tiddlers embedded therein.

* Retrieving a tiddlywikitext tiddler over the web rendered into HTML, or
  a collection of tiddlywikitext tiddlers rendered into HTML in an
  Atom feed.

By default this second feature, the server-side rendering of text
into HTML, is driven by an external package called WikklyText. This
package is no longer being maintained and has some issues:

* It is not compliant with modern packaging rules which cause
  installation difficulties for tiddlywebwiki and tiddlyspace[4].

* WikklyText does lots of things, not just parsing and rendering
  tiddlywikitext, making it quite large and complex, thus:

  * Repackaging just the parts we need is challenging[5].

  * Including it in the TiddlyWeb ecosystem's slow migration to
working with Python 3 is unlikely.

* I'm not certain but I think the fact the code is GPL makes
  incorporating it wholesale into the tiddlywebwiki codebase awkward. I
  reckon the author would be willing to make special dispensation, but
  see above and "large and complex". It would be icky, not just
  aesthetically.

I feel this leaves us with a few different options:

1. Do nothing. Just let people installed tiddlywebwiki using the
incantation described in [4]. I've already updated some of the
documentation to reflects, since that's the only way to get the
currently released code working. Pros: Nothing to do. Cons:
Installation would require some rather scary looking special
arguments that might put people off; No progress on making
tiddlywebwiki ready for Python 3.

2. Remove dependency on wikklytext. Pros: Easy to do. Cons:
server-side rendering of tiddlywikitext would be gone. In its place
the tiddlers would show up as plain text (on HTML and Atom requests,
they would still be rendered inside TiddlyWiki itself).

3. Someone else does the refactoring/porting of wikklytext to make
it useful for tiddlywebwiki. Pros: It gets done and its not me.
Cons: Over the history of TiddlyWeb there have only ever been a very
small number of contributors, so I'm not sure where this person
would come from[6].

I'd appreciate some input on what people would like to have happen. Do
you need or care about server-side rendering of tiddlywikitext?

Some important context when thinking about these issues:

* tiddlywikitext to HTML rendering can also be provided by
  twikifier[7]. It is what's used on http://tiddlyspace.com and is
  in use on my experiments with Tank[8]. It's nodejs though, so
  requires additional infrastructure and experience.

* The tiddlywebwiki package itself is becoming rather legacy so may
  not be the best site for a lot of effort:

  TW5 is the long term future of TiddlyWiki and is being developed with
  built in support for talking with TiddlyWeb.

  At the same time it's becoming clear that the style of TiddlyWiki
  generation used in tiddlywebwiki is probably not the best way to
  work with tiddlers. In Tank[8] the process is to load an empty
  tiddlywiki (from cache), load a bootstrapping bit of javascript
  (also from cache) that loads in the tiddlers associated with the
  wiki, activing plugins, themes, etc as needed.

The default option as this stage, barring convincing feedback in
some other direction, is 2.

Please let me know your thoughts. If you have questions please do
not hesitate to ask.

Thanks!

[1] http://tiddlyweb.com
[2] https://pypi.python.org/pypi/tiddlywebwiki
[3] http://tiddlyweb.tiddlyspace.com/HTTP%20API
[4] https://groups.google.com/d/msg/tiddlyspace/YCV2xbNclvM/cyrOlsbY7KsJ
[5] I made a go at this this morning. I made some small progress but the
resulting code was a terrible mess and on occasion entered an
endless loop. I think it would take me several days to get it working
properly and I don't really have the time, unless someone wanted to
sponsor me working those days?
[6] It would, however, be a very good learning project for anyone
interested in lexers, parsers, HTML generation and such things.
[7] https://www.npmjs.org/package/twikifier
[8] https://tank.peermore.com This is my next iteration of shared
tiddlyweb hosting. See https://tank.peermore.com/tanks/docs/Features

--
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 ti

Re: [tw] Re: Trying to escape from TW

[chris . dent]

On Thu, 28 Nov 2013, Marcus Bointon wrote:


I imported my TW into tiddlyspace, but the only export option I can find
exports back to TW, so Chris, I'd like to know how I can export to
JSON+HTML please. I don't have any non-standard macros, it's all vanilla.


You can get the JSON+HTML of just your tiddlers via the following two
URLs. This gets both the private and public tiddlers. Assuming your
space is named "cdent" then these URLs will work (that is, replace
"cdent" with the name of your space).

   http://cdent.tiddlyspace.com/bags/cdent_public/tiddlers.json?fat=1&render=1
   http://cdent.tiddlyspace.com/bags/cdent_private/tiddlers.json?fat=1&render=1

The result is a list of JSON objects, each object a tiddler with
(amongst other things) the following attributes:

* title: the tiddler's title
* tags: a list of tags
* text: the original wikitext of the tiddler
* render: the HTML of the tiddler

There are other URIs that can give you different collections but the
above is the most straightforward way to insure you are only getting
the tiddlers you imported. Find out more at:

http://tiddlyweb.tiddlyspace.com/HTTP%20API

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Trying to escape from TW

[Chris Dent]

One option that might work you is importing your existing wiki into 
TiddlySpace or TiddlyWeb and then exporting the content as a JSON-based 
collection of tiddlers that will have attributes that include both the 
original tiddler text and most of the resulting HTML[1]. You could then 
process this JSON to get the content into other tools. That is: The JSON 
becomes as useful intermediate format.

If this is an option that might be useful to you, shout out and I'll try to 
write up a step by step guide on how to do it.

[1] HTML that is generated by non-standard macros won't be supported

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: How to hide SiteInfo on TiddlySpace?

[chris . dent]

On Mon, 16 Sep 2013, Tobias Beer wrote:


First of all, I hope my somewhat challenging tone was ok...


Quite fine, welcomed in fact. Just understand that I and anyone else
will respond in kind and that at this stage in the development of the
project(s) and your level of engagement with the project(s) that what
matters most is not suggestions but implementations. Your efforts have
been great, so I'm not trying to suggest that nobody is noticing all
the great things you have done, but rather that it's a job that's
never done, for all of us.


The alternative is really straight forward. for me, the home tiddler of a
space is by default defined by the space, not by some shadow default that
is easily overwritten via inclusion.


Just made this:

https://github.com/TiddlySpace/tiddlyspace/issues/1101


Ergo, I think these two things would make sense ...

1) change the default recipe such that a public DefaultTiddlers tiddler is
created containing the TiddlyWiki default, yet not just as a shadow.


It's not a matter of changing the recipe (see the ticket).


2) PUT the same into all existing spaces that do not declare one and thus
are presumably quite agnostic about it or rather have the default, as I
don't know of any existing "apps" that define or depend on their own.


I'm not happy with backfilling tiddlers into existing spaces. There
are few enough active spaces that have some that are not in line with
the

Especialy since DefaultTiddlers is a TiddlyWiki requirement not a
TiddlySpace requirement: It would be hard to sure if a space was or
was not using TiddlyWiki.


For one, it speaks of some *ServerSettings *tiddler that neither seems to
exists, nor I ever heard of or were documented in a sensible way. That's
what I meant with "such contents should *never* be cemented in a space"
upon creation.


Right below where it mentions that tiddler it links to:

   http://docs.tiddlyspace.com/ServerSettings%20shadow%20tiddler

Yes, that's somewhat new, so _older_ GettingStarted tiddlers don't
have it, supporting your case that the content should not be frozen.


What I think were a step in the right direction is a GettingStarted space
that thoughtfully guides new or existing users when trying to figure out
certain concerns, and which provides details on meeting certain ends,
overcoming known issues, topics like how to get / set up / work with
themes, localisations, plugins and what not ...starting by guiding
different personas to possibly different sets of Q&A based on: What is it
that the user want to achieve on TiddlySpace?


That's a fine idea.


If this is the case, that seems fine, but there's no point doing the
second point until that content exists.


That may be right. But perhaps there is no need to start with content that
is mountains more comprehensive (if not bloated) than what is in the
current GettingStarted tiddler... although chances are that it will be
naturally better structured (not linear) and evolve ...well, being a space
and all.


Yes, one would hope so, but efforts to engage the community in the
shared generation of documentation for any of tiddlyweb, tiddlyspace
or tiddlywiki have never quite flown as much as we would like. At the
moment the tidlywiki docs on tiddlyspace are only in any relatively
good state due in large part to your singular efforts.


It is true that at the moment TiddlySpace's interface is predisposed
to the members of a space. This was by design. The plan was to then
move on to the non-member experience but, well, everyone left.


;-)


I should probably not state it quite like that. People left because
they were not well supported and found better opportunities elsewhere.
They were then not replaced. This is somewhat in contract with my
situation.


I see. Would this be it...

https://github.com/TiddlySpace/tiddlyspace


That is where the code is developed, yes. Some of the TiddlyWiki side
content is pulled in from elsewhere.


I believe Mario was already poking in that direction. Perhaps it's time to
think less of just being a user and more in terms of developer / "source
(code)" contributor. We'll see how that works out. I understand that there
might soon'ish be a point when you can only afford reviewing proposed
commits to the codebase and then pushing them... rather than doing much
active development.


Yes, this is unfortunately true. I still don't know for certain how
things are going to turn out, but it is looking quite likely that my
involvement will be decreasing.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email 

Re: [tw] Re: How to hide SiteInfo on TiddlySpace?

[chris . dent]

o the mix and I emphasize
*again* that this tiddler should *not* be one that is ever included.
Instead it should be *created* on space creation with the bare minimum of
default contents. Getting started should read... "Click
[[here|http://getstarted.tiddlyspace.com]] on how to get started on
TiddlySpace"... SiteInfo is already initialised meaningfully. If an app or
theme or whatever depends on a given default-tiddler it needs dedicated
instructions for making such an adjustment.


So let me see if I can parse out what you are saying, please correct
me where I am wrong:

* DefaultTiddlers _should_ be created at space creation time.
* GettingStarted should be tiny and point elsewhere to info.

If this is the case, that seems fine, but there's no point doing the
second point until that content exists.


I think it is more important to think of spaces as a presentational
platform and whichever non-tiddlyspace-member visits it might just know
little to nothing about TiddlySpace, or about tabs or "missing" or "public"
tiddlers or (included) "spaces" or backstage panels. In this case,
usability is predominantly the usability provided to those interested in
the contents created by a space owner.


It is true that at the moment TiddlySpace's interface is predisposed
to the members of a space. This was by design. The plan was to then
move on to the non-member experience but, well, everyone left.

It is encouraging that you have such interest and so many ideas, but
what we need in addition is people making changes to the code, doing
the open source thing.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: How to hide SiteInfo on TiddlySpace?

[chris . dent]

On Fri, 13 Sep 2013, Tobias Beer wrote:


Well, as I said, either they get my SiteInfo or they get my DefaultTiddlers
...I decided for it being SiteInfo (and tagging to DefaultTiddlers) to be
ok.


For spaces created in the last year they won't "get" your SiteInfo as
every new space gets one created for it (as well as a GettingStarted).
So yours will be clobbered by the recipe cascade.

If your space has a DefaultTiddlers and theirs does not then they will
get that.

What I would suggest you do for a space designed for inclusion is:

* Not change DefaultTiddlers, use the existing shadow.
* Edit GettingStarted to include getting started info and transclude
  SiteInfo

Then, visitors will see what your space is about but when they include
it they will not get SiteInfo, nor DefaultTiddlers nor GettingStarted.


After all, a SiteInfo tiddler shouldn't be something more vital to a space
than whatever is in some GettingStarted tiddler.


I don't undertand this statement. The SiteInfo is designed to be
exactly that: the description of the space, including tags which
indicate it's meaning[1].


As for the latter, I
believe a GettingStarted space is much more appropriate and
maintainable... seing how much false and irrelevant stuff is in the current
GettingStarted. o.O


Could you elaborate and if possible provide improvements?

[1]: See http://tsiscover.tiddlyspace.com/tsiscover for some
experimentation on how SiteInfo and its tags could be used.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: How to hide SiteInfo on TiddlySpace?

[Chris Dent]

On Friday, September 13, 2013 7:51:08 AM UTC+1, Kosmaton wrote:

>  Yes, I suppose it would be good if a fresh space would include a blank 
> DefaultTiddlers to evade this issue. Or if for some reason this has 
> downsides, something that warns the user.
>
>
It would need to be something other than blank, presumably whatever the 
default is at the moment.

Adding this wouldn't be too difficult but it seems a bit of a slippery 
slope. How many more will we need?

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Announcing TiddlyWiki version 2.8.1 Full Release

[Chris Dent]

On Monday, June 24, 2013 3:27:51 AM UTC+1, Eric Shulman wrote:

> This revision includes several important fixes to the new "HTML5 Download 
> Saving" functionality that was introduced in TW2.8.0.  In particular, this 
> update corrects an startup error that was preventing TW2.8.0 from loading 
> when viewed with older versions of Internet Explorer (specifically, IE6, 7 
> and 8).


I've been thinking about this hiccup some and wonder if might be possible 
to set up some automated smoke (or more) testing for TiddlyWiki on 
SauceLabs:

https://saucelabs.com

It should be possible to cause a regular build to be started up in all the 
browsers available via SauceLabs (there are many) and then it would at 
least be possible to declare that the current version doesn't crash on 
browser X.

There's a bit of similar (but by no means identical) automation in the 
tiddlyspace code:


https://github.com/TiddlySpace/tiddlyspace/commit/a8fbe3fc89ada92d14768d71340d6171a3a2d306#.travis.yml

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Announcing TiddlyWiki version 2.8.1 Full Release

[Chris Dent]

On Monday, June 24, 2013 3:59:42 PM UTC+1, Chris Dent wrote:

> That's because only tiddlywebwiki has been updated. The tiddlyspace code 
> itself needs to be updated for external:true to work with mainline.
>
> That will happen a bit later today. 
>

This is now up to date. 

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Announcing TiddlyWiki version 2.8.1 Full Release

[Chris Dent]

On Monday, June 24, 2013 9:45:49 AM UTC+1, PMario wrote:
>
> On Monday, June 24, 2013 9:53:55 AM UTC+2, Chris Dent wrote:
>
>> I've updated tiddlyspace.com so it is now using this version.
>>
>> @cdent
> ServerSettings: external: true 
> doesn't seem to load the new core.
>

That's because only tiddlywebwiki has been updated. The tiddlyspace code 
itself needs to be updated for external:true to work with mainline.

That will happen a bit later today. 

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Announcing TiddlyWiki version 2.8.1 Full Release

[Chris Dent]

On Monday, June 24, 2013 3:27:51 AM UTC+1, Eric Shulman wrote:
>
> Greetings All, 
>
> I'm pleased to announce that TiddlyWiki Classic v2.8.1 is now available 
> for general use. 
>
>
I've updated tiddlyspace.com so it is now using this version.

Thanks Eric!

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Announcing TiddlyWiki version 2.8.1 BETA 1

[chris . dent]

On Thu, 20 Jun 2013, Eric Shulman wrote:


On Jun 20, 1:58 am, cdent  wrote:

Double bump.
Please 
see:http://groups.google.com/group/tiddlyspace/browse_frm/thread/88fea849...


Profound apologies for the delay. I've been dealing with some serious
health issues that sidetracked me for a while, but I'm feeling
somewhat better and have more energy now, so I'm back to work on
updates to TiddlyWiki Classic...


I hope you're feeling better. Sorry for the pressure...

I'm in the process now of pushing the new beta out to tiddlyspace.com,

  http://cdent-t15.tiddlyspace.com/#version


IMPORTANT NOTE:
Because the previously posted beta changes are on the 'critical path'
for some users and the newest beta fix is relatively simple (though
still important), I intend to promote this build to full release THIS
WEEKEND.  If you have any concerns, please test this BETA 2 version
ASAP and report any problems to me immediately.


Excellent, I'll release a new tiddlywebwiki as soon as that happens.

Thanks very much.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Announcing TiddlyWiki version 2.8.0 full release

[chris . dent]

On Sun, 9 Jun 2013, cdent wrote:


I've made a pull request on github that has a potential fix. I'm
hoping Eric is able to integrate it or something like it soon.


Forgot the link:

  https://github.com/TiddlyWiki/tiddlywiki/pull/135

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Announcing TiddlyWiki version 2.8.0 BETA 1

[chris . dent]

On Sat, 1 Jun 2013, Eric Shulman wrote:


Going forward what would be good is to be able to retrieve the
equivalent of those files for:

* whatever the most recent mainline release is
* whatever the most recent beta release is


I think I've got this fixed up:


Awesome, I'll try to get this integrated with the tiddlyspace code in
the next couple of days. Thank you very much.

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Announcing TiddlyWiki version 2.8.0 BETA 1

[chris . dent]

On Tue, 28 May 2013, Eric Shulman wrote:


I don't know if main releases are getting an externalized version.
Perhaps Eric can say?


Currently, the main release doesn't generate an externalized version.
Exactly which file (or files) do you need me to create?


For the alpha, the files we used to get were:

http://tiddlywiki.github.com/alpha/empty.html
http://tiddlywiki.github.com/alpha/tiddlywiki_externaljs_tiddlyspace.html
http://tiddlywiki.github.com/alpha/jquery.js
http://tiddlywiki.github.com/alpha/jQuery.twStylesheet.js
http://tiddlywiki.github.com/alpha/twcore.js

Going forward what would be good is to be able to retrieve the
equivalent of those files for:

* whatever the most recent mainline release is
* whatever the most recent beta release is

Note that the file with the name `tiddlywiki_externaljs_tiddlyspace.html`
is "special" in the sense that the links it uses in the 

[tw] Re: Announcing TiddlyWiki version 2.8.0 BETA 1

[Chris Dent]

On Monday, May 27, 2013 4:39:20 PM UTC+1, Eric Shulman wrote:
>
> I'm pleased to announce that TiddlyWiki Classic, version 2.8.0 BETA 1, 
> is now available for viewing/download, here: 
> http://www.tiddlywiki.com/beta 
>

This version is now available on tiddlyspace.com if you set things up to 
use the beta release with your space. To do so create or edit a 
ServerSettings tiddlers so it contains (on a line by itself):

twrelease: beta

and reload your space. 
 

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Lazy loading. Any news?

[chris . dent]

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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Lazy loading. Any news?

[chris . dent]

On Sun, 19 May 2013, G.J.Robert wrote:


Adding a couple of remarks: I do sense the increase of TSpace server in
last months (also my ISP has also improved their cables...), and today my
15~17MB space loads in just 20s on my home laptop, it's really a great
improvement! I guess I can reconsider to move back to online editing. I'm
not sure how fast can it load in less stable and firm environment like
mobile networks (sadly we don't have LTE in Taiwan yet, and network speed
here is never comparable to those in the States and Europe)


We've recently discovered the extent to which reaching half way
round the world has an impact as well.

There's a change coming[1] in TiddlyWeb which may speed things up a
bit more (with standard TiddlyWiki) but is unlikely to make a huge
difference in a space your size: The sheer number of bytes that need
to be transmitted in a row is the controlling factor (thus the
desire for some kind of lazy solution).


I have just also tried "_tiddlywiki" of @apps on one of my smaller spaces.
It loads fine, only that it seems to break some functions or some plugins,
so my space looks a bit different in the top bar (it seems that the top bar
from other included spaces gets rendered first instead of my
customizations), and I've got "ReferenceError: hasClass is not defined"
every time a tiddler is opened.


Yes, there's definitely some work that needs to be done to make
_tiddlywiki work better. It needs more brains. If there were
unlimited time and energy I'd really love to get it correct and make
it the default way to view a tiddlywiki produced by TiddlySpace,
when online.

If you have a chance could you describe how you imagine the ideal
lazy system for tiddlyspace + tiddlywiki would work?

Thanks.

[1]
https://github.com/tiddlyweb/tiddlyweb/commit/de43319c459e5ea873f1129352a47f24c75c92f1

--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Announcing TiddlyWiki version 2.7.2 BETA 1

[chris . dent]

On Thu, 9 May 2013, PMario wrote:


On Wednesday, May 8, 2013 10:27:34 PM UTC+2, Chris Dent wrote:


The query string argument is appended to the url that loads a
tiddlywiki, for example for one of my spaces:

   http://cdent-t13.tiddlyspace.com/?twrelease=beta



I did test this with my @pmario space. But <> macro says 2.7.1.
The github repo should have 2.7.2 (beta) allready.


Your use of "external" in ServerSettings is confusing the system. You
need to get rid of that in order for you to be able to access the
beta (for which there is currently no externalized version, so it
fails during the "which empty.html do I use" stage of the code).
--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: Lazy loading. Any news?

[chris . dent]

On Sat, 27 Apr 2013, Ruler11 wrote:

On Thursday, October 18, 2012 11:55:42 AM UTC+4, Jeremy Ruston wrote:


I believe that there is also an implementation of lazy loading for
TiddlySpace, but I don't have the details to hand. TW5 will have lazy
loading built in as part of the core.


So any news on lazy loading now?


The most recent lazy loading version of tiddlywiki for tiddlyspace
remains:

  http://apps.tiddlyspace.com/_tiddlywiki

What it does is load up an empty framing for tiddlywiki and then loads
in the necessary parts from the server, a tiddler at a time.

There hasn't been much work on it because the tiddlyspace server itself
has increased in speed and except for really big spaces, or really
slow connections the win with using lazy loading is not that
significant.

Or perhaps a better way to put it is that the people who are really
concerned about speed have simply removed TiddlyWiki from the equation
and are working with tiddlers directly.
--
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 tiddlywiki+unsubscr...@googlegroups.com.
To post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Possible to make RSS reader?

[Chris Dent]

On Thursday, March 14, 2013 11:02:02 AM UTC, Mat wrote:

> With Google Reader sadly shutting 
> downsoon,
>  I'm wondering if it is possible (read: simple) to use TW instead? 
> I've seen stuff on RSS and feeds but always thought of that as too advanced 
> for me so I'm wondering if there perhaps already exist some kind of 
> solution or parts of a solution? Or maybe even solutionS - and in that 
> case, what are the differences among them?
>
> And would these things work on TiddlySpace? Would be cool if it is 
> possible to set up topical public newschannels there.
>

I had much the same thought when I heard the news this morning. There are 
tools in the TiddlyWeb stack which could (with work) allow a remote feed to 
be represented as a collection tiddlers. The start of that code exists as 
tiddlywebplugins.atombag[1].

That alone would not be enough to replicate the functionality provided by 
Reader. Besides the usual "google's huge infrastructure allows them to have 
all the data all the time and right now too!" there's also the 
read/not-read tracking.

One can imagine, though: 

* a tool which allows adding various feeds to recipes
* a tiddlywiki plugin or tiddlyspace SPA which tracks the read/not-read 
state on each feed for the current user in tiddlers owned by that user

It would be pretty interesting to make a prototype to see what the issues 
are. Unfortunately I won't be able to do this in the immediate future as 
I'm on holiday starting soon but would be very happy to help anything 
that's already started once I'm back.

For an implementation that works on TiddlySpace one concern would be 
protecting against bad content in the feeds or tools that access URLs 
incorrectly. Adding support for the remotebag system (which underlies 
atombag) can have the effect of opening up an open proxy on the web, and 
those are _bad_.

[1] https://github.com/cdent/tiddlywebplugins.atombag

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

[tw] Re: Announcment: TiddlyWiki version 2.7.1 release for general use

[Chris Dent]

On Monday, March 11, 2013 11:48:45 PM UTC, Eric Shulman wrote:

> This revision includes only ONE significant change: the internal 
> embedded copy of the jQuery library has been updated from v1.8.1 to 
> v1.8.3 in order to correct a Unicode/UTF-8 character encoding error 
> that was present within TW2.7.0. This update should allow documents 
> containing UTF-8 encoded characters (e.g., content in a non-Latin 
> language) to be more consistently recognized and saved/loaded without 
> 'mangling' those UTF-8 encoded characters. 
>

 Awesome, thanks. This has allowed me to return the build process for 
tiddlywebwiki[1] to using the online empty.html rather than a stale older 
version. So there's now a new release[2] and tiddlyspace.com is now 
sporting 2.7.1 TiddlyWikis.

[1] http://tiddlyweb.tiddlyspace.com/TiddlyWebWiki
[2] https://pypi.python.org/pypi/tiddlywebwiki

-- 
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 post to this group, send email to tiddlywiki@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki?hl=en.
For more options, visit https://groups.google.com/groups/opt_out.

Re: [tw] Re: What does TiddlySpace DO for me? What do I INTEND for it to do?

[chris . dent]

On Wed, 2 Jan 2013, stevesuny wrote:


(with the familiar
lament that Tiddlyspace remains hard to figure out how to do things like
answer questionnaires in a social space, so rather than try to figure out
the "reply to tiddler" thing that continues to baffle me, I decided to
sketch out answers inline below):


Often this lament is sourced in there being too many ways to do
things and points out that despite TiddlySpace's efforts to be an
application of the TiddlyWeb platform, it is itself a platform on
which there are many applications and thus many ways of being. This
is probably a key piece in the force at play discussed below.


I think the concepts developed from using tiddly as an experimental
platform might be replicated in other platforms: I remain unconvinced that
tiddlyspace (and tiddly in general) can move beyond a development
platform.  I might be wrong: mediawiki has demonstrated that the broad
public community can particiapte in using the wiki world, but I'm not sure
that tiddlywiki (and perhaps especially tiddlyspace) can or should become
that kind of platform.


This is an interesting observation and almost certainly true given
the current approach to development, marketing, documentation, etc.
Without focus it is many things to many people, doing many things in
many ways.


I'd be very interested in seeing advances in rendering of tiddlyspace in a
more friendly html context, so that my readers woulnd't necessarily feel
like they were in tiddly, but more in familiar html land.  Something like a
media-wiki skin for tiddlyspace: so that as an author, I could still use
tagging and transclusion, but as a reader, it would be more html-ish.  I've
seen some themes that do this, and I probalby need to explore more because
my sense is it exists already...


There are pieces, but they are not assembled into a coherent whole.
There are options, in and out of tiddlywiki, for presenting a single
page in a "normal wiki" kind of way. A critical missing piece is
support for the more advanced kind of tag handling that you do. I
don't perceive any technical roadblocks to such a piece existing: it
ought to be possible.


And then: more important: I'd like to see tiddlyspace move a bit into
creating a new role for the "group" -- to be useful in a higher education
setting, which for better or worse has significant issues with copyright
and privacy, I need for students in my classes to be able to have a private
space for reading, without the ability to write.  Less access than members,
more access than public. So I could mark each semi-private tiddler public
to a limited number of readers.  And then I'd need some systems to manage
access across a list of account holders.


Marking individual tiddlers semi-private is not a direct
possibility. Bags are the arbiters of access control so when you set
a policy on a bag you are setting it for all the tiddlers in there.
This was a core decision in the early design of TiddlyWeb based on
observations Jeremy had made of people using more granular access
management tools.

However the concept you want, what I would call a "protected bag",
is possible. That would be a bag which has a restricted read policy
and a more restricted write and create policy. For your purposes you
could set up the read policy to be a role, and give all the various
students that role for the duration of the class.

Then that bag could be included in one or more spaces.

Again, the tools for managing this sort of thing are not (yet)
brilliant.


Best wishes to the tiddlyspace community for a productive new year!


Thanks for your continued efforts and inputs. It's really great to
have the work that you are doing as a part of the project.

The coming year is full of all kinds of opportunities for
TiddlySpace. We need to marshal some resources, pick some goals, and
make it happen.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Problems to add a new member to tiddlyspace

[chris . dent]

On Tue, 18 Dec 2012, Cyrill wrote:


The copy of core function is possible by some importing a Download about
the backstage from local disk of older versions of the same tiddlyspace.
Is there a possibility to clean that space by preserving its actual content.


There's no quick solution.

But one option is to include the "apps" space, which includes a
"bulkdelete" app that you can run to select tiddlers you want to
delete.

After you do the include, you can reach the app at /bulkdelete


How to add a second member (guest) with no admin rights without beenig
already member in tiddlyspace? Or should I understand your words to double
my own membership by creating a new tiddlyspace?


TiddlySpace is set up so that you are either a member of a space or
you are not. Anyone who is a member has all the same permissions as
any other member (edit, delete, add more members). An appropriate
metaphor might be that members are housemates, not house guests.

So there's no concept of a member who is not an editor.

The usual process for adding members to a space is:

* Ask them to create a user (and their own space) on TiddySpace
* They tell you their username
* You add them to the sapce

If you have content which is private and you want to allow people who
are not members to be able to read it there aren't straightforward ways
to make that possible.

Some options are:

* http://privateer.tiddlyspace.com
* Adjusting the policy[1] of the bags that make up the space.


[1] http://tiddlyweb.tiddlyspace.com/policy

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Problems to add a new member to tiddlyspace

[chris . dent]

On Tue, 18 Dec 2012, Cyrill wrote:


the error concerned most of my tiddlyspaces light@tiddlyspace
tag@tiddlyspace or tworightfor@tiddlyspace.


@light and @tworightfor appear to be healthy in terms of their
contents, what usernames are you trying in those spaces. Keep in mind
that users must already exist on the TiddlySpace system.

@tag includes it's own copy of many of the core tiddlers, including
_space:

   http://tag.tiddlyspace.com/bags/tag_public/tiddlers/_space

This is not a good idea as it will break the core functionality. At
http://tag.tiddlyspace.com/_space it may be the case that you won't
even be given the option to try to add a user.

Do you recall what you did in that space to clone all those tiddlers
into your own space?

Are you aware of the difference between importing tiddlers and
including a space? If not I can explain it more clearly.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace RFC

[chris . dent]

On Thu, 22 Nov 2012, dickon wrote:


I think that Tiddlyspace should congratulate itself on achieving 6000 users
with really no marketing at all.


Thanks for the long and thoughtful response. I'll add some bits to the
roadmap spaces. Some comments below for sake of conversation...


First, selfishly, *don't do anything that will break the stuff that is
already there* - the AMBIT project now have over 30 mental health teams


Yeah, we intend to keep the core tiddlywiki properly functional
throughout whatever changes are made. In fact given sufficient resources
the hope is to make the tiddlywiki functionality better, overcoming
some of the browser based limitations that are hurting file-based
tiddlywiki's value proposition.

That "sufficient resources" bit is rather key, however.


Second, *get clearer about a few core things that you think people can do
with TiddlySpace* - what distinguishes it from other places in the web?


Bizarre question, but would you, as a trained inquisitor have any
interest in helping to tease that out? Most of our conversations about
such things tend to spiral into confusion, too much abstraction or
even despair.


Third* ask non-programmers what they think/want/like.*..


A big reason for the somewhat focus on dev-oriented people is because
the projects need more technical contributions in order to thrive.
We don't lack for ideas or plans. What we lack is consistent energy to
apply them. So the hope is that if we can generate some external
code contributions some of the gaps can be buttressed if not filled.

But that, of course, is just one course of action and many sources of
input need to be consulted.


  - What got me interested (as a non-techie) in tiddlywiki first was the
  ease with which I found I could write a fairly complex website that used
  links and tags to organise pages of information; it was the "*non-linear*"
  style of writing that fired me up.


There are seeds of interest within BT for re-implementing TiddlyDocs
style functionality with tiddlers but without tiddlywiki. This would
provide some more functionality for hypertext authoring if it happens.

But yes, it fires me up too. I've seen two styles of non-linearity:

* Write in long form and then decompose to chunks (the extraclusion
  style) that can be reused.
* Write in chunks and the compose to longer forms (the transclusion
  and "story" style).

I _think_ those may be the Dentist and Rustonian styles, if we want to
use tiddly personality to describe it.



  - Then, with the advent of tiddlySpace, it was the* inclusion* idea that
  seemed intrinsically beautiful,


Yes. AMBIT has done a great job using that feature presumably because
it was in the know as well as along for the early ride. Casual
visitors don't get a very good introduction, which is unfortunate.


*Conference?:* This leads me to suggest that one way forward would be to
think about that old fashioned idea of getting people together to share how
they are using TS...


This is a good idea. Ideally I'd hope that something like this would
be pushed by the community rather than the "core" (whatever that is).
There's two reasons for that:

* resourcing issues
* the community doing it would ensure it was more what it needs to be

I and/or Osmosoft could certainly help to orchestrate something
(provide space for example).


*Featured Spaces: *I have looked at the "featured


Good ideas. I'll summarize to @tsroadmap.


  - In general (an old chestnut I know) I suggest finding a budget to pay
  someone to write some really good user-friendly documentation (I have tried
  to write my own for the Tiddlymanuals


Saying "needing documentation is an old chestnut" is itself become
quite an old chestnut.


Incredible resource, incredible work from all of you who understand the
under-the-hood workings, incredibly grateful for the creativity and hard
graft that has got us this far.  Thank you.


Thank you for doing something meaningful with it.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: TiddlySpace RFC

[chris . dent]

On Mon, 22 Oct 2012, chris.d...@gmail.com wrote:


This is just a short list to get things started. I hope that people
will add their own. After there has been some discussion I'll
summarize the results and make a roadmap.


This is now in place at http://tsroadmap.tiddlyspace.com

I hope it captures the highlights of what has been discussed in
these threads (and elsewhere). If you feel something is missing or
wrong, please shout out.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace RFC

[chris . dent]

 "story").


3) I tried, and noted others trying, to use mGSD on TS but it doesn't work.
I wish it did.


I seem to be able to get it to work. Here's what I did:

* Got an empty mgsd.html
* Created a new space (@mgsdt1)
* Used the import backstage to import all the mgsd.html tiddlers
* Used the /_space app to remove the system-* includes
* Reloaded the tiddlywiki

This resulted in an apparently working mgsd, with the caveat that
saving needed to be triggered by clicking save changes. Automatic
saving was not on.

I then tried to make it so it was possible to create a new space that
used @mgsdt1 as a source space for turning the new space (@mgsd2) into
an mgsd space. I had to remove the system-* includes in that one too.

However it did not work because settings tiddlers like MgtdSettings
come from the @mgsd1 and when the @mgsd2 space want to update those
settings things go a bit wrong with permissions problems: An existing
tiddler is always saved back to its original location, unless plugin
code gets in the way to do a clone of some kind.

So, in order to get mgsd to work on tiddlyspace in an effective way
(one that doesn't require duplicating the plugin code all over the
place) a newly minted space that includes the mgsd stuff would need a
plugin to duplicate the various config and data starting point
tiddlers into the current space.

I suspect that someone (Simon?) could quite quickly cook up that
plugin. I, not knowing the guts of mgsd, don't really know which parts
would need adjustment.

However, I don't think there are large technical roadblocks to making
it happen.

I suspect that recent changes in the tiddlywiki core (related to
saving and merging defaultCustomFields) have improved the situation
here. It was probably a good deal worse a few months ago.

Hope this provides some insights.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace RFC

[chris . dent]

On Sat, 3 Nov 2012, Måns wrote:


Sorry that it's taking me so long time to answer - there are just so
many things going on at the job atm...
I have to keep up with everything..


No problem, is nice to keep the conversation going. A nice thing
about email is that gaps in time don't matter.


* Adapt a storage layer in the TiddlyWiki5 code that talks the
  Tiddlyweb http API, such that any TiddlyWiki5 can have or add a
  story which connects to a bag or recipe on a TiddlyWeb server.


Does it mean that you would be able to run a TW locally (node.js) and
it could behave as if it was hosted on a tiddlyspace domain?


More the opposite. You could run a TW locally and it could have
content which is hosted in the tiddlyweb domain. Manipulating
content in that (sub-)story would GET and PUT against a bag or recipe
on the tiddlyweb server.

I don't actually know what the details would be. I was mostly spouting
a possible idea that someone with greater knowledge of the guts of
TiddlyWiki5 could comment upon.


* Write a serialization for TiddlyWeb, very similar to the one in the
  tiddlywebwiki package, which creates and presents a TiddlyWiki5 file
  that gets filled in with tiddlers.


+1


I'd like to see _someone_ do this, and for that someone to _not be
me_. While I'm convinced that TiddlyWiki5+TiddlyWeb will be rather
interesting, it's not an itch I have, and it is critical, for the
health of the multiple projects involved, that the community be active
in the creation of features.


* Write a handler for TiddlyWeb that outputs an empty TiddlyWiki5
  primed (by query string or code injection) to load a bag or recipe.


+1


This would be a bit like: http://apps.tiddlyspace.com/_tiddlywiki
but with tiddlywiki5 instad of 2.x.


Can you describe in a bit more detail how performing the search within
the tiddlywiki is more valuable than doing the search in, for example,
a different browser tab. I don't doubt that it is for some, but I'd
like to understand better how.


It's the idea of being able to load tiddlers from a search result,
directly into your TW, which makes all the difference...


What do you do with them once they are in your TW?


Are you suggesting that the frontpage should be more revealing about
the interesting stuff that is already present on the server, so that
people can be encouraged by what they see?


Yep - Or alternatively some of the icons, on the frontpage, could link
to spaces which collect lists/links of/to spaces which enroll
themselves, simply by tagging SiteInfo with some defined tag..


That's a good idea. We've bandied around ideas like this in the past
but never quite followed through, in large part because of this whole
"what is this stuff for" question that lingers plus distribution of
resources and time.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace RFC

[chris . dent]

On Tue, 23 Oct 2012, Måns wrote:


When we create a new space maybe we could have the option to choose
(include) a theme/space from a pull down menu showing a list of any
space with a SiteInfo tiddler tagged with: "theme"?? It might impress
anyone who already know TiddlySpot, where you have "only" six themes
to choose from, and inspire creative users to share/create new wiki
themes on TiddlySpace.


Yes, this is something we've hoped to implement for quite some time: A
more interactive way of startup with different styles and
functionality.


* Accelerate progress on including TiddlyWiki5 in TiddlySpace.


- I'm not sure what this implies?


Back here

https://groups.google.com/d/topic/tiddlywikidev/BIRuexV0g-U/discussion

I asked the tiddlyweb and tiddlywikidev groups about interest in
developing a solution for intergrating tiddlywiki5 with tiddyweb, in
the form of a serializer or handler on the server, or http code in
tiddlywiki5. Other than a supportive comment from Jeremy, there was
zero response from the community, which suggests that no one is
interested in seeing TiddlyWeb and TiddlyWiki5 interoperate. I hope
that is not true.

So the "Accelerate" point above was another way of asking the same
question in a different context. Thus far the same suggestion stands:
people aren't that interested. I still hope that is not true.


* Intergrate TiddlySpace-wide search into TiddlyWiki.

+1
It would be very cool to have direct access to tiddlers on tiddlyspace
from a local wiki via an integrated search... Even better if a tiddler
(search result) could be temporarely opened/imported directly into
your local copy.


Can you describe in a bit more detail how performing the search within
the tiddlywiki is more valuable than doing the search in, for example,
a different browser tab. I don't doubt that it is for some, but I'd
like to understand better how.


* Expose greater admin functionality for manipulating bags and recipes.

+1
I guess what I miss is some simple apps where I can administrate
binary files/tiddlers with all the commands that I know from other
similar services like:
My files - Upload files (mimetype examples (images, htmls, pdfs
etc...))  and a list of already uploaded files/tiddlers sorted in
groups of (binary)type A, B, C etc...


So, is your interest here manipulating the contents of bags and
recipes (the tiddlers) of manipulating the bags and recipes themselves
(their policies and descriptions)?


* Make it easier to use tiddlers in apps outside of TiddlySpace.

+1
more TiddlyWiki macros and css should work/look right in "single
tiddler representations"... Eric's SnapshotPlugin seems to be able to
create html representations of single tiddlers or elements which look
exactly like the original tiddler in the wiki environment...
Maybe TS could have a similar option for single tiddlers: "Publish
single tiddler as html wikistyle" where macros like popups etc. would
work like they do in the wiki environment?!


The limitation here is in which macros are included in the twikifier
process. At the moment it only includes the default core macros plus
the TiddlySpaceLinkPlugin.

Others could be included, but they won't necessarily work.

I had held off on making further changes to twikifier because it was
going to get replaced by tw5ikifier but that stalled out due to
refactoring in TiddlyWiki5.



* Change the frontpage of tiddlyspace.com so it is more inviting.

+1
Links/menus pointing to ressources added by users (retrieval of links
to spaces where SiteInfo is tagged with sth - could be a simple
tagcloud )


Are you suggesting that the frontpage should be more revealing about
the interesting stuff that is already present on the server, so that
people can be encouraged by what they see?

Thanks for your input.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace RFC

[chris . dent]

On Mon, 22 Oct 2012, Handoko Suwono wrote:


What I am thinking is that I still need to find an online help in the space
where people can easily look and find it. Aside from my TW understanding.
Perhaps in the same local space.


Creating effective documentation has proven to be less easy than
hoped. In large part this is a question of resources, both in terms of
available energy and available skills. For myself, I'm best able to
construct documention in response to direct inqueries.


I don't know how to mingle with "other" spacers and some permissions to
allow them to comment in one's space.


Thank you. This is a very important statement as it captures in a
short statement a clear gap: You know that something ought to be
possible, and want it to be but don't see the straight path to making
it possible.

For now you might have a look at: 
http://docs.tiddlyspace.com/#%5B%5BGuide%20to%20Socialising%20on%20TiddlySpace%5D%5D


--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] TiddlySpace RFC

[chris . dent]

In the past couple of days TiddlySpace (on http://tiddlyspace.com/)
reached its 6000th user so now seems like an opportune time to request
some feedback from the various communities that use it and those that
have thought about it but don't yet.

I'm writing different versions of this message to different groups.
This, the first, is to the tiddlywiki group, I'll also write to the
TiddlyWeb and TiddlySpace groups[1] if time allows.

I'm writing here first because of those 6000 users, most of them are
using TiddlySpace as a place to host their content in TiddlyWikis.

For those who don't know TiddlySpace combines TiddlyWeb[2] and
TiddlyWiki to provide a flexible, multi-user and multi-domain hosting
service for tiddlers with system-wide search, public and private
storage, atom feeds, binary tiddlers and a slew of tools to make it
easy to create, curate and share your content.

Over the past year most of the development on TiddlySpace has been
focused in a few main areas:

* Stabilizing and optimizing the service for speed and concurrency.
* Enabling what are being called apps: Web applications on
  TiddlySpace, using tiddlers, outside of TiddlyWiki.
* Enabling "real-time" information flows with tiddler information
  flowing over websockets.

As is the case with most open source projects these priorities come
about as a result of who is doing the work and who is being the
squeaky wheel.

This message is a request for people to squeak and speak up about
what they want or need from TiddlySpace. Doing so will help to form
priorities and ensure that TiddlySpace serves all the people who use
it or want to use it. Any comments or propositions are encouraged
and desired.

If you don't have something narrative to contribute, then commenting
on any of the following (+1 or -1) propositions would also be useful,
along with any editorial remarks (such as how to accomplish the
proposition):

* Make the default TiddlyWiki presented by TiddlySpace be more like
  empty.html with the option to easily add functionality. Or...

* Make the default TiddlyWiki be flexible and powerful with
  TiddlySpace functionality with the option to easily be more like
  empty.html.

* Provide more blessed themes and verticals and make them easier to
  find.

* Accelerate progress on including TiddlyWiki5 in TiddlySpace.

* Intergrate TiddlySpace-wide search into TiddlyWiki.

* Enable a type of lazy loading by default in online TiddlyWikis while
  ensuring that downloaded Tiddlywikis still operate effectively.

* Allow login and registration with github/facebook/google.

* Improve the documentation (if you +1 this one you are obliged to
  editorialize on how).

* Expose greater admin functionality for manipulating bags and recipes.

* Make it easier to use tiddlers in apps outside of TiddlySpace.

* Change the frontpage of tiddlyspace.com so it is more inviting.

This is just a short list to get things started. I hope that people
will add their own. After there has been some discussion I'll
summarize the results and make a roadmap.

Thank you for your participation and help.

[1] http://groups.google.com/group/tiddlyweb
http://groups.google.com/group/tiddlyspace

[2] http://tiddlyweb.com/

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Lazy loading. Any news?

[chris . dent]

On Thu, 18 Oct 2012, Jeremy Ruston wrote:


I believe that there is also an implementation of lazy loading for
TiddlySpace, but I don't have the details to hand. TW5 will have lazy
loading built in as part of the core.


There are a few different implementations but none was ever blessed as
the official solution.

Part of it was that things just keep getting faster on TiddlySpace, so
a sizable number of tiddlers, under the right conditions, can load
quite quickly, if they are coming from cache.

Another part is that there was insufficient feedback and development.

This is because the people who expresssed interest in having large
collections of tiddlers were in three groups:

* Didn't mind the slower load times: once stuff is loaded it is there
  and future operations are quite fast. Plugins exist that will load
  up new content as it "arrives" in the space.

* Wanted lots of tiddlers, but didn't care about TiddlyWiki, moved to
  using the HTML representation.

* Liked the concept of lazy loading, but didn't like the way in which
  timeline, search and tags were affected by it.

Identifying a larger group of participants from this latter set would
be useful as it could provide some robust feedback and other
contributions.

Without those contributions it is unlikely anything will happen.

In any case:

My space, which has 1099 tiddlers, takes about 3 seconds to load in
standard wiki mode (no laziness).

The /_tiddlywiki app (available from the @apps space[1]) is a special
customization of tiddlywiki that loads an empty tiddlywiki html +
javascript and then bootstraps itself by loading content after initial
start. To go from starting it to working TiddlyWiki takes longer than
3 seconds.

By the way, in total there about 825,000 revisions of 355,000 tiddlers
on http://tiddlyspace.com/

Of course all this stuff is on serversides. If what you're after is
standalone, then I think TiddlyWiki5 is probably going to be the
tool needed. For seriously large instances it will be important for
whatever the tool is to do what amounts to memory management on
tiddlers: disposing the least recently used.

[1] http://apps.tiddlyspace.com/
--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Alternative for saving TW

[chris . dent]

On Thu, 18 Oct 2012, Poul wrote:


I certainly sympathize with Chris's disappointment in the ability of
server-based TW solutions to gain developer support. But then, I am not a
Python believer, and if I were to invest a serious amount of effort in the
problem, I would most definitely go the Node.js path. As it is, I am more
likely to just pick the fruits of whatever is useful from tweb in the
context of giewiki (like server-side wikifiers).


When TiddlyWeb was started nodejs was still a glimmer. At the same
time TiddlyWeb was meant to operate as a reference for a tiddler HTTP
API, so I figured a language that is highly readable was a good
choice. The hope, at the time, was that there would be developer
engagement and parties interested in other environment would port the
API to those environments. As far as I know that hasn't happened.

Except that at one point I did start working on node port of
TiddlyWeb, tiddlynode[1], but it didn't get too far because of...

...lack of engagement from interested parties.
...real users and real life on TiddlySpace demanding more time.

Also since it was created in early node days, the idioms are ugly, so
the code is rather hard to read and use. It did, however, drive some
improvements to the testing infrastructure for the Python version.


But I must take some time to look into what Jeremy is doing with TW5.


I posted in tiddlywikidev[2] suggesting that making a tw5 serializer
for TiddlyWeb was a great way for someone to get involved in making a
big contribution to the TiddlyVerse. The only person who responded was
Jeremy, agreeing with me.

That, to be blunt, is not a great sign. What needs to be done?


[1] https://github.com/cdent/tiddlynode
[2] https://groups.google.com/d/topic/tiddlywikidev/BIRuexV0g-U/discussion
--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Alternative for saving TW

[chris . dent]

On Fri, 19 Oct 2012, Mark S. wrote:


That's a lot of stuff to set up.


That's part of my point. It looks complex, and to some extent it is,
but it is considerably less complex than what is happening under the
covers when you do something like install a web browser. The
difference is that the work to create the covers (an installer) on
TiddlyWeb has not been done.

This is, in large part, because of lack of engagement with people who
bridge that gap between folk like me and Poul and potential users on
the various architectures.

So my questions surround the single question of: Where are those
people?


At this point, TW is no longer the light-weight, run-anywhere personal wiki
solution. There are already information and wiki systems that can run on a
USB stick with no install and no significant memory restriction. For that
matter it would be easier just to carry a copy of FF 3.6.


If the part of tw that matters to you is the "light-weight,
run-anywhere personal wiki" then I agree that carrying around a copy
of FF 3.6 is probably a very good solution.

What tools like TiddlyWeb and gieWiki provide is flexible reuse of
content. The tiddler concept taking onto the net.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace First Time User Experience

[chris . dent]

On Thu, 26 Jul 2012, tejjyid wrote:


Thanks Chris - see below. I wouldn't want to say I've had an epiphany, but
I think I've started to crystallise some ideas.


I'm glad things are starting to fill in. They are for me too.

More below:


One of the early goals of TiddlySpace was to make it easy for people
to establish known-good collections of plugins that other people could
then include in their spaces using the inclusion mechanism. When I say
"people" here, I mean members of the using public.


I'm not sure how that's working, BTW, in terms of the "known". No mind,
I'll think about that as I get moving on documentation. I'm thinking of
starting a thread here for discussions about documentation
strategy/standards.


Yes, it's not yet working in the common case. I think there are at
least three forces working against it (in addition to the already
oft-stated documentation issue):

* The common TiddlyWiki behavior is to copy plugins around, because
  that's how it works in offline TiddlyWiki.
* There's no warning mechanism, when you copy in a plugin, that tells
  you "Hey, did you know you could just include this from space X?"
* We're all a bunch of hippies around here and neither want to force
  people to do things a certain way, nor do the work people might be
  able to do themselves, so there aren't many officially blessed
  spaces.


I understand that now, but I note that you introduced a "new" concept,
TiddlyWeb to explain it.


That's pretty common when explaining anything isn't it?


Well, I hope not, but never mind.


We may wish to take this part of the conversation over to
alt.philosophy.epistemology or something...


I think there's quite a big difference between this description, and the
idea that TW is an application running on a datastore called TiddlySpace
(Which was my understanding of something you had said elsewhere). I still
think it's a big difference (hence misleading) but I doubt now whether the
difference will be that important in the overall scheme of things. For
different users, there may well be different descriptions.


Part of the fuzziness is the result of the several different visions
of people involved in creating the system and the documentation. The
great big tiddler database in the sky with many applications and tools
using them is the model that fits in (and comes from) my brain but
many consider that model too abstract.


Yes, sorry, that was unnecessarily snarky on my part.


I didn't mind. I think a bit of snarky helps to keep the internet
moving. I remember the good ol days of constant goodhearted flame
wars.


Yes, although I like "edit" for journalling on the bus.


That's part of why I made it. My hope is that tools like it can be
used as lego for people to build environments, piece-wise, that work
for them.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlyWiki 2.6.6 Alpha

[chris . dent]

On Wed, 25 Jul 2012, PMario wrote:


- Where jquery_alpha is still 1.6.4

what's about a new jquery version, for external alpha?


It appears that the files in alpha directory are not fully updated.
The TiddlySpace build process gets the following files:

http://tiddlywiki.com/beta/empty.html
http://tiddlywiki.com/alpha/empty.html
http://tiddlywiki.com/alpha/tiddlywiki_externaljs_tiddlyspace.html
http://tiddlywiki.com/alpha/jquery.js
http://tiddlywiki.com/alpha/jQuery.twStylesheet.js
http://tiddlywiki.com/alpha/twcore.js

Looking at

https://github.com/TiddlyWiki/tiddlywiki.github.com/tree/master/alpha

it appears _only_ empty.html has been updated, none of the externalized
files. So it's no wonder that your having the issues you reported at:

https://github.com/TiddlySpace/tiddlyspace/issues/984

Before the migration the tiddlywiki.com/alpha directory had no
index.html so it was possible to inspect the directory to see if
things had been updated properly. This is no longer possible so I
assumed, last time I built TiddlySpace, that the old alpha build
requirements were still being followed, but I was wrong.

So we'll need to resolve that to get external working.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlyWiki 2.6.6 Alpha

[chris . dent]

On Tue, 24 Jul 2012, PMario wrote:


I use ServerSettings
twrelease: alpha
external: true

- Where jquery_alpha is still 1.6.4
- if I use - external: false it seems to ignore the parameter It still
is external
- I need to use - externalX to disable external


external is a flag, so any value is treated as "true". If you want to
not have external then removing or renaming (as you did) the parameter
is the way to go.

How's it working out?

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace First Time User Experience

[chris . dent]

en that is fungible
  by downloading a tiddlywiki and syncing it back up later).

* TiddlyWeb has the concept of users, which TiddlySpace uses to have
  the concept of members. Any space can add as any members as the
  existing members wish to add. For example you can add additional
  authors in the andrewsimon space from here:

 http://andrewsimon.tiddlyspace.com/_space

* Those additional representations provide a mode of tracking stuff.
  For instance you can subscribe to the Atom feed of a space, by which
  a group can then track what's going on it.

* TiddlyWeb supports a technique to avoid what is described as the
  lost update problem[1]. What this means is that multiple people can
  edit in the same space at pretty much the same time with low risk of
  clobbering content.

* There's a project called AMBIT on TiddlySpace which is a good
  example of collaborating groups:

   http://tiddlymanuals.tiddlyspace.com/
   http://ambit.tiddlyspace.com/

Those things above are for collaboration where there is a collection
of people who have already identified as some kind of group and
through the membership concept have access to the same content. There
are also proto-groups which collaborate by seeing other people's
content and annotating their own to refer elsewhere. The following and
reply concepts in TiddlySpace (which are not yet fully formed) are
designed to support this kind of interaction.


It's not a given that I'm necessarily interested in the Tiddlywiki
interface - it's just what I happen to know right now, and what I guess
most people coming into Tiddlyspace know. What I'm interested in is
functionality around collaborative work practices.


At the moment the most effective way to learn about and improve that
interest is to talk with people who are in the same boat. It's what
I'm interested in as well. Your input and feedback, but most
importantly conversation, will drive things forward.

[1] http://www.w3.org/1999/04/Editing/
--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpace First Time User Experience

[chris . dent]

On Sat, 21 Jul 2012, tejjyid wrote:


I created a tiddler called "tsjuly" as per some posting related to
this...should I repost here?


The idea was to tag the tiddler tsjuly, so if you add that tag, it
will show up on the radar.


I have never had a clear idea of how Tiddlyspace is supposed to work, nor
its relation to Tiddlywiki. Pretty much every time I try to use some plugin
- painfully tracked down - it turns out to be TW specific. The comment made
further down here - that TW should be about TW and TS about tiddlers I find
particularly bewildering: I thought TW was about tiddlers? And I thought TS
was about collaboration?


What do you mean by "TW specific"?


And how does one use TW, if not through tiddlers? And what/where are the TS
interfaces that expose tiddlers without exposing TW?


The idea there is that TiddlyWeb makes it possible to work with
tiddlers outside of tiddlywiki. For example your tsjuly tiddler
(assuming this is yours) can be reached on the web like this:

   http://andrewsimon.tiddlyspace.com/tsjuly


From which I can make a bookmark, that quotes it:


   http://cdent-bkm.tiddlyspace.com/tsjuly


(And in fact, how does that gel with this, from the docs space?
A space may be thought of as a TiddlyWiki hosted on TiddlyWeb.)


As you've noted the docs are a bit inconsistent, but it is true that a
space may be thought of as a tiddlywiki hosted on tiddlyweb. It may
also be thought of a collection of tiddlers that are present on the
web. My main space doesn't use tiddlywiki at all, it just operates as
a more standard wiki:

   http://cdent.tiddlyspace.com/

You might ask, why bother? What do I gain from not using TiddlyWiki.
For me what I get is more direct access to the tiddlers without
TiddylyWiki being in the way. Each of those tiddlers can be access and
edited directly over the HTTP API that tiddlyweb present.

The canonical URI of that HelloThere tiddlers is:

   http://cdent.tiddlyspace.com/bags/cdent_public/tiddlers/HelloThere

it can be accessed in other representations. Here are some (but not
all):

   http://cdent.tiddlyspace.com/bags/cdent_public/tiddlers/HelloThere.txt
   http://cdent.tiddlyspace.com/bags/cdent_public/tiddlers/HelloThere.json
   http://cdent.tiddlyspace.com/bags/cdent_public/tiddlers/HelloThere.atom

Using the web API it can be changed and manipulated by a large number
of tools, including, but not limited to TiddlyWiki.


Plus you say "We haven't been very good about exposing functionality":
Endorsed!


You might wish to read this posting in the [tiddlyspace] group where I
explain some of the reasons for this:

   https://groups.google.com/d/msg/tiddlyspace/g3SOnPGX8_U/_7KhIpyrv_QJ


I'm actually quite keen to get involved in documenting stuff - but I have
no idea where or how to start.


I recommend you get in contact with pmario and mat mentioned in that
thread referenced just above. They appear to have some plans and hopes for
improving and consolidating the TiddlyWiki aspects of TiddlySpace.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: What's happening to my TiddlySpace?

[Chris Dent]

On Monday, July 16, 2012 12:42:43 PM UTC+1, Vincent Yeh wrote:

> I am not seeing anything when logged in but do see everything if logged 
> out. What is happening to my TiddlySpace?


That's very odd. Can you provide some more information such as:

* The URL of your space.
* The username you are logged in when visiting the space (if not the same 
as your space).
* The type and version of browser you are using.
* A general time of when you last tried (so that the logs can be browsed in 
case there are errors in the logs).

(As a general rule all four of those pieces of information are needed when 
dealing with TiddlySpace questions, or for that matter any web related 
service.)

Thanks. 

-- 
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To view this discussion on the web visit 
https://groups.google.com/d/msg/tiddlywiki/-/svN16NmYg1kJ.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: Beta of new TiddlySaver.jar with a renewed certificate

[chris . dent]

On Tue, 13 Mar 2012, Jeremy Ruston wrote:


Yes, that was my mistake again, I was on the wrong branch. Please try again now,


Yeah, looks right now, thanks.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: Beta of new TiddlySaver.jar with a renewed certificate

[chris . dent]

On Tue, 13 Mar 2012, Jeremy Ruston wrote:


I think I've done that successfully, let me know if how it looks,


Both show version to be 2.6.5a2 data August 19, 2011, which makes them
older than the release 2.6.5 (October 6, 2011).

So either the version info is wrong, or the built thing is not HEAD.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: Beta of new TiddlySaver.jar with a renewed certificate

[chris . dent]

On Tue, 13 Mar 2012, Jeremy Ruston wrote:


Bah, yes, apologies, I'm afraid thats my fault, I replaced the
existing content of the directory because it appeared to be an out of
date. Is it just beta/empty.html that you need? And it needs to be
restored to a copy of the current head build, is that right? If you
have the file to hand, so much the better.


I think both the /alpha/* files and /beta/* files where all out of
date, potentially older than the 2.6.5 release. So one of the three
following are probably best:

* make new alpha and betas from HEAD
* make new alpha from HEAD, copy current released empty.html to beta
* copy current released empty.html to both beta and alpha

That latter is not ideal though as quite a pile of stuff is brought in
from the alpha dir (externalized stuff and whatnot):

https://github.com/TiddlySpace/tiddlyspace/blob/master/Makefile#L12

Thanks.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: Beta of new TiddlySaver.jar with a renewed certificate

[Chris Dent]

In the process of updating the TiddlySaver.jar file did the 
http://tiddlywiki.com/beta/empty.html get removed? 

That file is used in the TiddlySpace build and deployment process to 
support the twrelease query parameter when loading a tiddlywiki (you can 
choose "alpha", "beta" or not set the parameter to get the default).

Since that URI is currently 404-ing, I either need to change the 
TiddlySpace build process, or wait for a beta to be back in place to do a 
deployment.

When the twrelease parameter was added the idea was that it would allow 
people to very easily test TiddlyWiki alphas and betas with their existing 
content simply by loading a slightly different URI. The idea was paired 
with a commitment/hope/wish that there would be regular alpha and beta 
releases of TiddlyWiki (Classic).

If there aren't going to be such things I should remove the functionality 
or otherwise the twrelease will point to things that are older than 
existing versions.

If there are (I hope there will be as the testing capabilities are very 
useful) then please let me know when new versions will be up.

Thanks.

-- 
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To view this discussion on the web visit 
https://groups.google.com/d/msg/tiddlywiki/-/6GF1xgjJHfUJ.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] Re: Catching Ideas....how to start?

[Chris Dent]

On Friday, March 2, 2012 4:18:33 PM UTC, skye riquelme wrote:
>
> Guess like most people, I often have brilliant ideaswell ideas at 
> leastin the middle of doing something else...and have that 
> conflict between needing to concentrate on what I am doing.or stop 
> and record the idea. 
>

I recognize that this is not really a direct answer to your question but I 
thought I should mention that the use case you describe here is pretty much 
exactly the same as one of the use cases that TiddlySpace hopes to 
solve[1]: capturing, refining and synthesizing ideas, on the fly, as you 
have them. We captured that in the second 
manifesto: http://manifesto2.tiddlyspace.com/ [2]

In particular, the takenote editor is designed so that it can create 
tiddlers that eventually show up in your tiddlyspace, even when not 
connected to the network, from multiple devices, particularly smartphones. 
If you're always on the same device, always with access to your TiddlyWiki, 
then this doesn't matter and I reckon TiddlySnip, as @whatever suggests, 
may be right for you, or straightforward to adapt.

I, however, use multiple devices and need my tiddlers on the network and 
accessible in multiple contexts, so TiddlySpace works out quite nicely.

Ben Gillies work on bookmarks and reply functionality in TiddlySpace 
provide another vector for getting content into TiddlySpace which may 
provide some ideas you can borrow for your task (with or without 
TiddlySpace).


[1] There are others, including being a framework upon which tiddler-base 
applications can be built. I wrote some thoughts related to these things 
recently: http://cdent.tiddlyspace.com/TiddlySpace%20For%20Me 

[2] It is probably about time for a third manifesto?

-- 
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To view this discussion on the web visit 
https://groups.google.com/d/msg/tiddlywiki/-/6-FVtFPaXVMJ.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: O2 dongle won't access Tiddlyspace - when 3 does - why?

[chris . dent]

On Thu, 23 Feb 2012, dickon wrote:


Sorry to hear you have been unwell - hope you are better now.


Nearly there.


When they go online it works fine until they try to use tiddlyspace, when
they just get a white screen, with the tiddlyspace "target" icon, and that
is that...


I've added a Cache-Control: no-transform to every response from the
server. According to the specs this is supposed take care of it. Can
you let me know if it is does?


By the way, Jon Lister and Joshua Bradley's new ambit theme is nearly ready
and is looking great (http://ambit-theme-v3-test.tiddlyspace.com/#)


It's looking very nice. Some very interesting tricks in there.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlyWiki Development News

[chris . dent]

On Tue, 31 Jan 2012, Jeremy Ruston wrote:


Great, that looks right. I think you'll need to add the shadow tiddler
support from App.js as well at some point.


What for? The usual HTML rendering for Tiddly{Web,Space} ignores
shadow tiddlers as artifacts of TiddlyWiki, not tiddlers in general.


You may also be interested in the new disableHtmlWrapperNodes option
for the WikiStore constructor; it suppresses the DIVs that are
otherwise inserted to help the refresh mechanism. In your environment
you probably won't want them.


Oh yes, that sounds useful.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlyWiki Development News

[chris . dent]

On Tue, 31 Jan 2012, Jeremy Ruston wrote:


That sound about right?


Bang on, yes.


https://github.com/cdent/cook.js/commit/961713675461c93668b385e731ede015622b5360

Has a very simple prove to myself that I get it.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlyWiki Development News

[chris . dent]

On Tue, 31 Jan 2012, Jeremy Ruston wrote:


Do you have many tests for twikifier? It'd be cool for TW5 to be able
to adopt/adapt them.


Sadly no. I was in such a rush and flailing around with such ignorance
when I was making twikifier that I was mostly just throwing code and
hoping. The irony is that that's a great time to write tests, but you
know...

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlyWiki Development News

[chris . dent]

On Fri, 27 Jan 2012, Jeremy Ruston wrote:


Hey Jeremy, what's the status of your wikifier. It's it play-with-able
in a standalone kind of way? If so where and how?


With some caveats I think this is probably a good time to start
investigating. I think the code is capable of what you need, but it's
still rather in flux, and so can be changed in response to your
requirements.


Thanks for the detailed info. I shall attempt to dig. Some comments
within.


- Error handling is probably a bit inadequate


I don't know about you but I've found effective error trapping and
(especially) awareness quite challenging with node.


So, I've tried to arrive at an implementation that supports both
approaches. One of the hallmarks of the design is the aggressive use
of caching to support efficient selective updating of the DOM. I think
a big area of discussion around this integration is how we can ensure
that our respective caching strategies work well together.


The finally implementation of twikifier has just one cache: it caches
(in memcache) the (skinny) JSON that is uses to makes its pseudo store
(see below).


Using the existing implementation, an asynchronous function to wikify
a tiddler goes like this:

- Initialise a WikiStore object
- Asynchronously load the tiddler into the wikistore
- When it's loaded, parse the tiddler to obtain a list of its
dependencies (this is a synchronous operation)
- Loop back to recursively load the dependent tiddlers
- Call the store.renderTiddler() function to obtain an HTML rendering
of the tiddler, which is also a synchronous operation


This is quite similar to what twikifier does, the differences coming
about mainly because twikifier is accepting requests for rendering over
a unix domain socket:

* on the socket accept a string which is
** the current collection (bag or recipe in which the tiddler lives)
** the text of that tiddler
** the cookie of the current user (in case the bag or recipe needs
   auth to access the collection)
* if the text has a macro, load the skinny JSON 
** make a store with tiddlers without text (supporting timeline

   style macros, <> type transclusion is done afterwards,
   recursively from the other side of the socket)
* call wikify on the text faking in a dom thing from jsdom

The part of your description that is most interesting is the
dependency resolution.


The WikiStore object is the equivalent of the TiddlyWiki() object in
the old code; it's a collection of tiddlers. The Tiddler object is
intentionally simple: just an immutable collection of fields. The
WikiStore also needs be configured with the parsers and macros that
you want to use. I'm currently using a module called App.js to
centralise the WikiStore configuration steps for both browser and
node.js configurations of the code:

https://github.com/Jermolene/cook.js/blob/master/js/App.js


so:

* make a store
* register parsers
* What are tiddlerInput and tiddlerOutput?
* install macros
* addTiddler
* get its dependencies
** if null: load all tiddlers into store
** if list: load each of those tiddlers into store
* renderTiddler

That sound about right?

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] REMINDER: tiddlyspace.com down this afternoon

[chris . dent]

Sorry for the crosspost, but want to make sure the target audience
(tiddlyspace users) get the message. Note that there is now a google
group dedicated to tiddlyspace[1].

tiddlyspace.com will be down this afternoon in a window between 3pm -
6pm GMT. The actual downtime is expected to be 4pm-5pm, but during the
window there may be outages.

This is to perform hardware upgrades.

[1] http://groups.google.com/group/tiddlyspace

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

[tw] TiddlySpace Annual Report 2011

[chris . dent]

I started graphing the monthly change[1] in users and spaces on
http://tiddlyspace.com about a year ago, so now seems like an
opportune time to reflect on that year.

As of last night there are

3,839 users operating
6,237 spaces containing
  526,341 revisions of
  251,432 tiddlers having
  156,657 different titles[2]

In addition to providing a place where people can host their
TiddlyWiki for free, TiddlySpace has also become a service for
experimenting with the use of tiddlers as the data model for
simple and innovative web apps. Both activites have helped to drive
improvement and development in TiddlyWiki and TiddlyWeb[3]. For
example, as a result of the large number of users on TiddlySpace,
performance and scaling problems in TiddlyWeb have been identified and
solved, sometimes by several orders of magnitude.

If there has been one clear learning from the last year it is that the
tiddler concept is useful generally, not just in TiddlyWiki. The same
principles that make it flexible and powerful in TiddlyWiki are just
as present on the open web, driven by TiddlyWeb giving each tiddler
its own unique URI.

While the TiddlySpace service has matured well from a technical
standpoint, there is still a long way to go to make it easy, effective
and pleasant to use. Most of its power is obscured behind incomplete
or unintuitive interfaces and motivated individuals who hope to find
documentation are stymied: The documentation is either hard to find,
missing or incomplete.

For the second year of TiddlySpace these are the things that must be
fixed. TiddlySpace is a free service and open source project. While
BT/Osmosoft provide resources for hosting the service and leading
development of the project those resources are limited and priority
must be given to BT's internal use of TiddlySpace. This means that for
the public/free TiddlySpace version to be its best the community that
uses it must help to make it great by participating in active and
contentious feedback and dialog. I wrote about this a while ago[4].

To that end I've gone ahead and created a google group specifically
for discussing the use and improvement of tiddlyspace from the
perspective of people who use it:

http://groups.google.com/group/tiddlyspace

(Discussion of the technical guts can carry on in the tiddlyweb group
as TiddlySpace is basically an assemblage of TiddlyWeb plugins.)

I know that people have talked about wanting to use forums or
TiddlySpace itself as the engine for discussion and documentation, but
until such a time as we have the resources for hosting a forum or
developing a forum engine in TiddlySpace, google groups will have to
do. With good email hygiene and discipline about effectively capturing
useful information to wikis, it can work.

Thanks to everyone for helping make TiddlySpace the success it has
been thus far. The community is what makes an open source project
live.

[1] http://tscount.tiddlyspace.com/
[2] this means there are approximately 100,000 tiddlers with the same
names stored in different bags.
[3] http://tiddlyweb.com/
[4] http://cdent.tiddlyspace.com/On%20Being%20Free%20and%20Not%20Product
--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Tiddler-Based-Communication-Protocol

[chris . dent]

On Fri, 18 Nov 2011, tiddlygrp wrote:


Additionally I propose to add an optional  journal or history field
analogous to Ward's federated wiki (
https://github.com/WardCunningham/Smallest-Federated-Wiki/wiki/Story-JSON
).


If you put the journal in the tiddler, then when trying to reconcile
a lot of forks you need to merge up the journal.

That's non-trivial. And what does it get?


By just adding these fields nothing substantial has to change in the
core.  Nothing needs to change in the ui! and the use of tw.

But these changes are building blocks for tiddler identification,
server side integration and federation.  Let's see how they are used.

Keep it simple.  Keep tw extensible.


+1

I had a think on how to bootstrap and also enforce uuids yesterday,
which led me to an important conclusion:

Assuming the tiddlywiki core did not get a uuid field extension, or
an old tiddlywiki interacted with a server:

* when the server first saw the tiddler

if tiddler is new in this context (not persisted on this server):
   if a uuid field is included:
  persist that field with the tiddler
   else:
  add a uuid field
if tidler is not new in this context:
   if a uuid field is included:
  replace it with the uuid of the stored tiddler

The idea behind this pseudo-code is that it would insure that
the server has authority about uuids: You can't give it false uuids.

However the only way this works is if the server can determine,
accurately, if the tiddler is new in a certain context, and in order
for it to determine that it must use something other than the uuid
as the identifier for the tiddler (in the tiddlyweb context this
would be bag.name and tiddler.title). But then you have clobbered
the capability for uuid's to transcend renames and similar actions.

So, if you want real ids they gotta happen at the birthplace.

(We mostly know that, but just reinforcing the point.)
--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: Tiddler-Based-Communication-Protocol

[chris . dent]

On Thu, 17 Nov 2011, Poul wrote:


My point about UUID's was that strictly speaking, you really need to
know what it is that the uuid identifies, and that's a semantic issue.


Ah, okay, somewhere along the line I thought we had already gotten
past that. I think in relation to the need for revision identifiers
to be separate from identifiers for the tiddler which "has" those
revisions.


I could imagine that a collection of tiddlers had the same value for a
named uuid, because either:

* they were different versions of the same tiddler.


This is what I was thinking. And those different versions may exist
anywhere (in a tiddlywiki file, on a server, on some other server).
In aggregate they are "the tiddler". How the resolution of all those
revisions is handled is a _different_ issue from identifying that they
are in fact the same tiddler.


on two things:
1) What the tiddler-identifying id is named (simple).
2) What it means to have identified a tiddler. Not so simple. IMHO.


Yes.


If, say, you receive a document that contains 42 more or less
different tiddlers having 17 different uuids, what can be deduced
about their relationships..?
A plausible interpretation would be 17 tiddlers, some of which have
several versions. You may of course choose not to accept such a
document. Or try to figure out which is the current version - but
don't assume that it's the one with the latest timestamp.


This is aligned with my thinking.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.

Re: [tw] Re: TiddlySpaceMailBox - messages from/to on TiddlySpace

[chris . dent]

On Thu, 17 Nov 2011, Måns wrote:


Was it all there was to it? - or does my @mailbox result in more
conflicts?


As far as I can tell things are fine now.

--
Chris Dent   http://burningchrome.com/
[...]

--
You received this message because you are subscribed to the Google Groups 
"TiddlyWiki" group.
To post to this group, send email to tiddlywiki@googlegroups.com.
To unsubscribe from this group, send email to 
tiddlywiki+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/tiddlywiki?hl=en.