Discussion:
[tw] [TW5] Cornell Notes / TB
(too old to reply)
Tobias Beer
2015-01-05 22:40:56 UTC
Permalink
With respect to the method discussed here:

*Cornell's Note Taking Method*
https://groups.google.com/forum/#!topic/tiddlywiki/4OSPF3TeEWE

...rather than starting to implement anything right away,
I have decided to try and define a system and corresponding requirements for
implementing the method:

http://cornell.tiddlyspot.com

If you're interested, please let me know...

- what you think of what you read
- if you can imagine how that would work
- if you find it comprehensible and coherent
- what you think of the design choices
- what's missing

~

When I set out to jot down those requirements, I stumbled over one *major
problem* that any requirements engineer would have trying to use TiddlyWiki
for the job. A basic requirements system needs one thing, above all else:
requirement IDs that never change (like an issue tracker would, as well).
In other words, every single line-item you see in that wiki should be a
tiddler with a requirements ID which, today, I would manually sort into a
requirements tree... and later hopefully into one that is
nested-drag-sortable.

I would find it very welcome and practical if at some point TiddlyWiki
provided means to...

- define a template tiddler
- have an incrementable id field at that tiddler, possibly prefixed,
e.g. *req-1*
- have the id field increment every time a new tiddler is created based
on the template
- perhaps be able to define the number of zero-padded digits, so you get
*req-00001*
- be able to link to any tiddler via its requirement-id
- I guess implementing *<<req 00001>>* can already be done

Best wishes, Tobias.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Jed Carty
2015-01-06 01:24:56 UTC
Permalink
That is a much more organized thought process than I had when I made mine.
It looks good to me and seems coherent enough.

I think that you should allow for the possibility that a note may have more
than one question associated with it, and that a question can be associated
with multiple notes. That could probably be done by giving each question a
field that contains a list of all of the rowidex values for the notes
associated with it. It may be a good idea to have the ability to add tags
or something equivalent to each note to allow searching for notes/questions
on specific topics.

Since deleting a note breaks indexing I was trying to use in
http://inmysocks.tiddlyspot.com/#Note%20Taking%20Test%202 I made an
action-increment widget in the MathyThing plugin to increment the id but I
haven't gotten around to making a version of the note taking that uses it.
The widget doesn't have an option for leading zeros, but I don't think that
would be too hard to add. The plugin would benefit from the ability to give
a date/time or other format to be incremented so I should probably do that
anyway.
If there is a button to add a new note/question as part of the view
templates, and that button was the only thing used to add them, then that
button could trigger the incrementing each time it was pressed but some way
to detect when the template is used would be better because it would help
avoid duplicate ids.
As you said, the prefix part can be done using WikiText. And the prefix
would probably be a good way to distinguish between
classes/projects/whatever is being tracked. (The MathyThing plugin is here:
http://inmysocks.tiddlyspot.com/#MathyThing%20Plugin I updated the
documentation a bit so hopefully it is actually understandable now.)

I don't think there would be many new things required to make the backend
part. The view editing ability and the drag and drop list sorting would all
have to be implemented, but the way you have it laid out the backend looks
mostly independent of the display methods.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Tobias Beer
2015-01-06 02:28:15 UTC
Permalink
Hi Jed,
Post by Jed Carty
I think that you should allow for the possibility that a note may have
more than one question associated with it, and that a question can be
associated with multiple notes.
You're right. I am starting to think I was a little too focused on
mimicking pen and paper.

Having these many-to-many relationships between notes and questions does,
however, seem to require that all questions and all notes are individual
tiddlers rather than fields of a note-tiddler holding all notes and
questions.

Maybe the draft was by far stretching the abilites of fields too much,
in that it may not be very desireable for fields to hold too much content.

As for visualising such a many-to-many relationship,
I wonder what Cornell suggests how to show that on paper, I guess it
doesn't (?).
So, maybe, mimicking the pen-and-paper approach 1:1 isn't the best idea,
after all.

Looks like those requirements will need a thorough reqrite with such a
paradigm shift...
That's ok, it's why I drafted them anyways to get a meaningful design
before implementing anything.

That could probably be done by giving each question a field that contains a
Post by Jed Carty
list of all of the rowidex values for the notes associated with it.
Nope, with the current spec that won't be possible,
because in the above draft, a question dooesn't have a field, it is a field.

If I wanted to save a many-to-many mapping based on that paradigm,
I would need some extra field storing these relationships, e.g.:

*cn-mapping: cq1-cn1 cq1-cn2 cq3-cn5*

And then split and parse all these relationships so as to display them,
perhaps by having dim-styled clones of questions showing up in the
corresponding RowIndex, either duplicated (one question for many notes) or
deferred (many questions to one note, thus more than one question listed in
a row, those that are mapped not being directly editabe).

It may be a good idea to have the ability to add tags or something
Post by Jed Carty
equivalent to each note to allow searching for notes/questions on specific
topics.
That is probably the #1 reason why storing notes or questions as fields is
a really bad idea.

To me, it now seems to boil down to this:
Questions and notes will (have to be) tiddlers with id-style names. (see
below)

Since deleting a note breaks indexing I was trying to use in
Post by Jed Carty
http://inmysocks.tiddlyspot.com/#Note%20Taking%20Test%202 I made an
action-increment widget in the MathyThing plugin to increment the id but I
haven't gotten around to making a version of the note taking that uses it.
The widget doesn't have an option for leading zeros, but I don't think that
would be too hard to add. The plugin would benefit from the ability to give
a date/time or other format to be incremented so I should probably do that
anyway.
Please, let me know when you have it working.
Post by Jed Carty
If there is a button to add a new note/question as part of the view
templates, and that button was the only thing used to add them, then that
button could trigger the incrementing each time it was pressed but some way
to detect when the template is used would be better because it would help
avoid duplicate ids.
As long as we have one reliable way to increment, I am fine.
If users managed to use the template without that button doing the
incrementing,
then they're clearly doing something wrong.
Post by Jed Carty
As you said, the prefix part can be done using WikiText.
And the prefix would probably be a good way to distinguish between
Post by Jed Carty
classes/projects/whatever is being tracked.
I guess, after all, it would make sense that there is only one index and
that questions, in fact, increment the very same index as notes, however,
are somehow distinct, e.g. by having a *Question* tag, whereas notes could
have a *Note* tag.

For example, a note would thus be stored as...

title: MA101-1
tags: Note

contents of the note with index=1 for the class Math-101

...and a question as...

title: MA101-2
tags: Question

contents of the question with index=2 for the class Math-101
this question is not linked to any note yet!

The relationships between questions and notes could then be entirely
created using tags, e.g.

title: MA101-3
tags: Question MA101-1

contents of the question with index=3 for the class Math-101
referring to note MA101-1

One could even have a note referencing another note, e.g. a "dependent
note"...

title: MA101-4
tags: Note MA101-1 MA101-2

contents of the note with index=4 for the class Math-101
referring to note MA101-1 and
referring to question MA101-2

I don't think there would be many new things required to make the backend
Post by Jed Carty
part. The view editing ability and the drag and drop list sorting would all
have to be implemented, but the way you have it laid out the backend looks
mostly independent of the display methods.
When you say "backend"... what exactly do you have in mind? Configuration
such as...

- the global tag for notes
- the global tag for questions
- the note prefix for a given note tiddler, e.g. a "class"

?

Best wishes, Tobias.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Tobias Beer
2015-01-06 02:43:20 UTC
Permalink
So, back to the drawing board it is, especially when it comes to reodering
notes and questions.
With many-to-many relationships, this now seems to require a lot more
flexibility.
I will make a mockup to visualise what I have in mind for drag and drop
behavior and also ViewModeEditing.

I think we should make this thing right from begin on, so no special edit
templates.

Preferably, editing would work via inline editing (for transcluded
contents) in *ViewMode*,
possibly also for fields, e.g. tags.

Without it, I would simply have the note-overview be a
ViewMode-only-dashboard for a note collection,
which may become cumbersome the longer the list of notes becomes of a given
collection, e.g. a class.

Viewing a single note or question, a jump-to-collection button comes to
mind, which...

- opens the overview if closed
- scrolls to the tiddler as rendered in the overview

That way you can jump back and forth between...

- collection tiddler <> note tiddler of collection
- collection tiddler <> question tiddler of collection

In fact, the notes-and-questions-are-tiddles approach would even allow to
cross reference between different collections, i.e. to have MAT101-10 be
listed as a question at MAT102-5.

Best wishes, Tobias.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Mat
2015-01-06 14:59:09 UTC
Permalink
Very interesting stuff. I believe a well implemeted solution could become
very popular (e.g among students).

Just so I dont' misunderstand - you write:

* implement a dedicated ViewMode <http://cornell.tiddlyspot.com/#ViewMode>
and EditMode <http://cornell.tiddlyspot.com/#EditMode> template for
CornellNotes <http://cornell.tiddlyspot.com/#CornellNotes>
** both templates render IndexedRows
<http://cornell.tiddlyspot.com/#IndexedRows> stored at CornellNotes
<http://cornell.tiddlyspot.com/#CornellNotes>
This would mean some kind of indexing table in (tiddler) CornellNotes,
right? And the actual notes would still be via individual tiddlers (albeit
in their fields) so that we still stick to the paradigm with tiddlers being
the primariy unit and citizen in TW, right? (As opposed to somehow lifting
out fields to be "it" that we deal with.)

I am particulaly intrigued by the concept of ViewModeEditing
<http://cornell.tiddlyspot.com/#ViewModeEditing>, also outside of
CornellNotes. In fact, just the other day I wrote a little text
<http://tidbits.tiddlyspace.com/#TWYSIWYG>on how TW should feature three
modes for a tiddler!

In general for note-taking, I think it must be very easy to create new
notes. I've brought up Cintanotes before which works better than TW, for
me, when quickly taking notes but still wanting something with discrete
units (i.e not just a text editor or pen+paper where you write everything
togheter). A power feature for this in TW(C) can be found in Simon Bairds
mGSD where you can type in the content for soon-to-be-created multiple
tiddlers at once, and then have them created with a clck of a button. Very
effective and the user does not have to bother with the "Create New. Jump
around between fields. Click Done. Reopen to change. ...etc". I did mockup
(image) a few days back that I think I posted but I'm not sure. Tell me if
you haven't seen it. I won't post it in this message to not deviate too or
hijack your thread.

Regarding cn-id - I am very interested in this. It would be easy to imagine
students wanting to share notes and unique identifiers woudl be necessary
if we managed to create a social system as discussed in other threads.
Would this cn-id also mean a way to specifiy a URL straight to this?

I also favor the n:n relationship for the smiple reason that our minds work
this way. BTW, hearing this I can't help but think of Felix TiddlyMap,
formerly called TaskGraph. He may have some input on this that could make
Cornessnotes possible to present in this format? Fits well for when the
note taking is to learn stuff.


Ok, easier said than done - but they're just friendly ideas.


<:-)
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Tobias Beer
2015-01-06 16:01:59 UTC
Permalink
Hi Mat,

I will be rewriting the whole thing, because I have come to the conclusion
that it is absolutely vital that

1. individual notes need to be individual tiddlers
2. there is more to a note than perhaps a question
- e.g. a reference, a hypothesis, an idea, a comment, etc..., etc...
- so, questions are only one way to extend upon notes

Anyhow, the idea now is to have all these snippets be individual indexed
tiddlers whose index has a prefix corresponding to a topic or scope, e.g. a
class. Then there would be cross-references between notes and other types
of snippets tagging to that topic, displayed in this two column layout,
however... more than just questions.

We're actually much headed in the direction of Alberto's BottomTabs only
just now those tabs are more to the left ...and preferably all related
items are listed in one list, rather than buried in individual tabs. Let me
make a mockup to illustrate what I have in mind.

Best wishes, Tobias.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Jed Carty
2015-01-09 21:53:15 UTC
Permalink
Tobias,

I have a working action-increment widget and it can now take a prefix
string and a length for zero padding as inputs so you could get req-00001
and increment it correctly. I am still looking through the parsing required
to properly increment dates and time with it, so that part isn't included
yet.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Tobias Beer
2015-01-10 18:36:13 UTC
Permalink
Found it. ;-)

Try not to overload your code with all the documentation.

Rather put that into some *ActionIncrement *tiddler along with some
examples.

I think it's a useful thing. Wanting to use it, perhaps make it a bit more
concise and pull to the core?

Not sure about that mathything in its entirety, haven't looked at it yet.

Best wishes, Tobias.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Jed Carty
2015-01-10 18:56:53 UTC
Permalink
I have been learning javascript so I have been putting comments in the code
to remind myself what is going on, but I will make a separate tiddler for
that. I do need to learn javascript best practices for this sort of thing.

The rest of the plugin should probably get a lot of work before it sees
much use, I realized that everything aside from the action-storecount
widget has the same problem as the link-fields widget I made where the
functions for most of them are triggered by rendering, so I need to make
them action widgets and find out how to make a daemon that works in the
background to get the continuously updating functionality.

On that subject, do you know of anywhere I could look to find examples of
how to make a background process like that? I am assuming the best way to
do it would be to have a continuously running process that periodically
polls the input fields and triggers an update whenever they change.
--
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+***@googlegroups.com.
To post to this group, send email to ***@googlegroups.com.
Visit this group at http://groups.google.com/group/tiddlywiki.
For more options, visit https://groups.google.com/d/optout.
Tobias Beer
2015-01-10 21:07:07 UTC
Permalink
Post by Jed Carty
On that subject, do you know of anywhere I could look to find examples of
how to make a background process like that? I am assuming the best way to
do it would be to have a continuously running process that periodically
polls the input fields and triggers an update whenever they change.
Unfortunately, I have no experience with this either.

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