OneNote--Uneven Development

[srdiamond]

From the standpoint of outlining, OneNote provides the basis for a real advance, in that it allows the construction of metaoutlines. Outlines in their containers can be arranged into an outline structure, allowing depiction of more abstract relationships

But then, on the other hand, OneNote carries over at least one of the grotesque outlining behaviors of Word. Try this. Create an outline structure lik



Put the cursor after A above and hit return. What happens? A new sibling to A is created, which accrues B and C as children, which A loses. This is absurd. Rational outlining programs create a child of A, coming before B and at the same level.

 

[Ben M. Schorr, MVP-OneNote]

From the standpoint of outlining, OneNote provides the basis for a real
advance, in that it allows the construction of metaoutlines. Outlines
in their containers can be arranged into an outline structure, allowing
depiction of more abstract relationships.

But then, on the other hand, OneNote carries over at least one of the
grotesque outlining behaviors of Word. Try this. Create an outline
structure like A
B
C
Put the cursor after A above and hit return. What happens? A new
sibling to A is created, which accrues B and C as children, which A
loses. This is absurd. Rational outlining programs create a child of A,
coming before B and at the same level.

Hmmm...when I create that outline and then go back up to A and hit enter
I get a new "B" inserted after "A" and the former "B" and "C" become "C"
and "D" respectively.

 

[srdiamond]

That's what I'm trying to say. Sorry if I wasn't clear

Word/OneNote creates a heading parallel to A, and B and C become C and D, and C and D are subordinated to B

What enter should do is create a B that is subordinate to A and parallel to the new C and D, with C and D (the old B and C) remaining subordinate to A, not the new B. CaseSoft's NoteMap, which I generally find underwhelming, does this correctly. (I don't think incorrect is too strong a characterization. There may be other conventions, but the one adopted here by Word/OneNote makes no sense.

From the standpoint of outlining, OneNote provides the basis for a real
advance, in that it allows the construction of metaoutlines. Outlines
in their containers can be arranged into an outline structure, allowing
depiction of more abstract relationships
grotesque outlining behaviors of Word. Try this. Create an outline
structure like


Put the cursor after A above and hit return. What happens? A new
sibling to A is created, which accrues B and C as children, which A
loses. This is absurd. Rational outlining programs create a child of A,
coming before B and at the same level

Hmmm...when I create that outline and then go back up to A and hit ente
I get a new "B" inserted after "A" and the former "B" and "C" become "C
and "D" respectively
-
-Ben
Ben M. Schorr, MVP-OneNot
OneNote FAQ: http://home.hawaii.rr.com/schorr/Computers/OneNoteFAQ.ht
SchorrTech Blog: http://www.thespoke.net/MyBlog/bschorr/MyBlog.asp

 

[Ben M. Schorr, MVP-OneNote]

That's what I'm trying to say. Sorry if I wasn't clear.

Word/OneNote creates a heading parallel to A, and B and C become C and
D, and C and D are subordinated to B.

What enter should do is create a B that is subordinate to A and
parallel to the new C and D, with C and D (the old B and C) remaining
subordinate to A, not the new B. CaseSoft's NoteMap, which I generally
find underwhelming, does this correctly. (I don't think incorrect is too strong a characterization.
There may be other conventions, but the one adopted here by
Word/OneNote makes no sense.)

Actually I have to disagree. It's very simple to make a subordinate if
you want one, press [Enter] to get to the new line, then [Tab] to make
it subordinate. B & C remain B & C and you get a "1." subpoint of A.
I think I'm going to create siblings more often than children in that scenario,
and since the conversion from sibling to child is an easy one keystroke
it doesn't seem especially onerous. Most outlines, I suspect, are more
wide than deep - i.e. more siblings than children.
The alternative would be to have [Enter] create a child, then [SHIFT]+[TAB]
to convert the child to sibling.
Also you'd have to have some logic in the application that knew you were
inserting a new line in an existing outline as opposed to just continuing
with your new outline. Otherwise you'd type "A", enter your text, press
[Enter] to get to "B" and end up with a child instead of a sibling. Everytime
you went to add a sibling at any level you'd have to [SHIFT]+[TAB] to get
it right. That's a lot of extra work.
My opinion anyhow.

 

[Grant Robertson]

From the standpoint of outlining, OneNote provides the basis for a real advance, in that it allows the construction of metaoutlines. Outlines in their containers can be arranged into an outline structure, allowing depiction of more abstract relationships.

But then, on the other hand, OneNote carries over at least one of the grotesque outlining behaviors of Word. Try this. Create an outline structure like
A
B
C
Put the cursor after A above and hit return. What happens? A new sibling to A is created, which accrues B and C as children, which A loses. This is absurd. Rational outlining programs create a child of A, coming before B and at the same level.

Actually, some would expect it to create a new sibling of A after C.
Especially if A is collapsed. So many people expect so many different
things in this regard. To get what you want the best thing to do is put
your cursor before the B and press enter. Every outliner or word
processor will do what you want if you do it this way.

 

[srdiamond]

I've used the Word outliner for years, yet have managed to overlook that feature. And it isn't like I've avoided systematic treatments of Word. I submit I was better off not knowing of that capability

Why? Because it is alien to the underlying conceptual scheme of 'select an object and operate on it.' If you put a tab in a heading, without selecting the heading, you expect the tab to operate the way it does anywhere, by advancing the matter immediately following the exclamation, not to follow its own bright idea of tabbing the heading as if it were childless

I have often heard people complain that Word's outliner was too hard to use, and I didn't know what they were talking about. Now I think I know. Word/OneNote applies not one, not two, but three distinct conceptual schemes to outlines: 1) selecting the whole heading operates on that heading, consistent with the logic of outlining; 2) selecting a part of a heading operates on what is selected, as if it were simple text, not an outline; these two are desirable, but Word adds 3) tabbing (and its equivalents and inverses) with the cursor at the begining of a heading treats the text not as a heading; not as text; but as if it consistented of meaningless strings, to be manipulated according to tab logic

If you know enough to avoid the tab absurdity or you use Word so much that the process is always automatic, with no mental overhead, you're OK. Otherwise, the user is forced to hold too much in mind or (if he doesn't) he risks large-scale error, not readily correctable upon later discovery

----- Ben M. Schorr" <Ben M. Schorr>, "MVP-One wrote: ----

It's very simple to make a subordinate i
you want one, press [Enter] to get to the new line, then [Tab] to mak
it subordinate. B & C remain B & C and you get a "1." subpoint of A. -
-Ben
Ben M. Schorr, MVP-OneNot
OneNote FAQ: http://home.hawaii.rr.com/schorr/Computers/OneNoteFAQ.ht
SchorrTech Blog: http://www.thespoke.net/MyBlog/bschorr/MyBlog.asp

 

[Guest]

I wonder why that didn't line wrap. This is what it said,
linewraps imposed

I've used the Word outliner for years, yet have
managed to overlook that feature. And it isn't
like I've avoided systematic treatments of Word.
I submit I was better off not knowing of that
capability.

Why? Because it is alien to the underlying
conceptual scheme of 'select an object and
operate on it.' If you put a tab in a heading,
without selecting the heading, you expect the tab
to operate the way it does anywhere, by advancing
the matter immediately following the exclamation,
not to follow its own bright idea of tabbing the
heading as if it were childless.

I have often heard people complain that Word's
outliner was too hard to use, and I didn't know
what they were talking about. Now I think I know.
Word/OneNote applies not one, not two, but three
distinct conceptual schemes to outlines: 1)
selecting the whole heading operates on that
heading, consistent with the logic of outlining;
2) selecting a part of a heading operates on what
is selected, as if it were simple text, not an
outline; these two are desirable, but Word adds
3) tabbing (and its equivalents and inverses) with
the cursor at the begining of a heading treats
the text not as a heading; not as text; but as if
it consistented of meaningless strings, to be
manipulated according to tab logic.

 

[srdiamond]

Yes, there are various defensible conventions an outliner
could adopt, but that doesn't excuse choosing an
indefensible one. The one thing the user is not primed to
expect is that creating a subordinate immediately
following A would cause A to lose B and C, with the
result that the user could easily reassign B and C
without even knowing it.

There is of course a defense of sorts, the pragmatic one
that Ben raised. How bad is it to have ad hoc commands,
if they make some things easier to do? My view is that
such unnecessary complication rarely pays off, because
its justification ignores its cost in attentional
resources.

-----Original Message-----

 

[Peter Engrav \(MS\)]

"Indefensible" is a bit harsh. Or, depending on one's personality, a
challenge...

Let me try to explain some of the details of why OneNote is the way it is on
this ...

It's certainly the case that some users are expecting "Outlining" (they're
thinking in terms of parent-child relationships between paragraphs) and that
others are expecting "Text With Indents" (they're thinking of a series of
lines of text each with an indentation). Trying to come up with a
consistent set of commands that satisifies all is hard. Having a variety of
commands to satisfy each constitutency is costly (mostly in UI complexity -
that's the path toward being called "bloated").

Given that we're trying to satisfy a diverse audience (which means we can't
in all cases be "right") we should try to be as predictable and internally
consistent as possible. And we should try to maximize "overall"
convenience.

Another thing to keep in mind is that as we design this sort of thing we
have to consider not only what happens if you methodically press a single
key expecting to modify your document in a particular way. We also have to
consider all of the "intermediate" states that you go through as you're
rapidly typing and make sure nothing surprising happens along the way.

Consider the outline srdiamond posed ...

Apples<cursor>
Delicious
Granny Smith

Where we're talking about which of the following you get if you press enter.

Outcome "Current" (what OneNote actually does) ...

Apples
<cursor>
Delicious
Granny Smith

Outcome "Suggested" (what you're asking for) ...

Apples
<cursor>
Delicious
Granny Smith


First, consider Ben's quite reasonable argument. Presume half the users are
going to expect either behavior. So no matter which way you go, half of
your users are not immediately happy. What do those folk have to do to get
happy? If OneNote does "Suggested" then the unhappy users would have to
press shift+tab to recover. If we do "Current" then they (it's the other
"they") have to press tab. Pressing tab is within the intuitive grasp of
far more users than is shift+tab. So the "maximize overall convenience"
arguments leads us towards "Current" (unless our assumption is wrong and a
significant majority of users expect "Suggested").

Next, consider these related situations.

Oranges<cursor>
Apples

Melons<cursor>

What should pressing enter do in these cases? I suspect nearly everyone
will agree that the right outcomes are ...

Oranges
<cursor>
Apples

Melons
<cursor>

.... where in neither case did the cursor end up indented. Otherwise just
typing a simple list would require a bunch of shift+tab-ing. Said slightly
more geekily "If the cursor is at the end of a paragraph (1) and that
paragraph has no children or is the last paragraph in the outline then
pressing enter should create a sibling to paragraph (1)."

Here's another case.

Oranges<cursor>Apples
Delicious
Granny Smith

Surely this should create ...

Oranges
<cursor>Apples
Delicious
Granny Smith

.... rather than ...

Oranges
<cursor>Apples
Delicious
Granny Smith

Said geekily "If the cursor is in the middle of a paragraph pressing enter
should split that paragraph into two paragraphs that are siblings of one
another."

So now we have two cases where pressing enter should create new paragraph
that's a sibling of the existing paragraph (outcome "Curent") rather than a
new child (outcome "Suggested"). Said another way - if we were to implement
"Suggested" it would need to be a special case of the form "If the user
presses enter AND the cursor is at the end of a paragraph AND that paragraph
has at least one child paragraph already THEN indent the resulting paragraph
so you're left editing the new first child of the paragraph."

This kind of special case is dangerous. Basically making a design decision
like this amounts to pursuing "correctness" in one relatively narrow
circumstance at the cost of "predictability/consistency" - a strategy that
has not proved particularly effective. (That's not to say we never write
special cases like this - they just need to be much closer to a slam-dunk
where we believe almost all users expect the "special" behavior).

Finally, consider the nasty "intermediate state" version of this problem.

Paragraph10
Paragraph11
Paragraph12<cursor>
Paragraph4
Paragraph5

What if the user has paragraphs #4 and #5 (both indented one level) just
left sitting around at the end of their outline. They're garbage and
they're likely to delete them before too long but they haven't bothered yet.
They're touch typing (perhaps not even looking at the screen). What if the
next thing they want to do is create a new "child" paragraph for #12? If #4
and #5 weren't there, they'd have to type <enter><tab>. If we implemented
"Suggested" then because #4 is present (at the moment a child of #12) the
right thing to type is just <enter>. But the user is quite likely in this
case not to notice that #4 is there, or at least not to expect that its
presence would impact what happens. So they'll type <enter><tab> and now be
indented TWICE and be correspondingly confused.

Said geekily "the state of the outline in paragraphs after the one with the
cursor in it should not affect editing behavior".

Hence our current behavior.

Make sense? Did I say anything monumentally stupid in there anywhere?
Comments? Suggestions?

- Peter Engrav (MS, OneNote Development Manager)

 

[srdiamond]

----- Peter Engrav (MS) wrote: ----

First, consider Ben's quite reasonable argument. Presume half the users ar
going to expect either behavior. So no matter which way you go, half o
your users are not immediately happy. What do those folk have to do to ge
happy? If OneNote does "Suggested" then the unhappy users would have t
press shift+tab to recover. If we do "Current" then they (it's the othe
"they") have to press tab. Pressing tab is within the intuitive grasp o
far more users than is shift+tab. So the "maximize overall convenience
arguments leads us towards "Current" (unless our assumption is wrong and
significant majority of users expect "Suggested")

-----------

Everything in this scenario is within the grasp of the average user realistically hoping to use this kind of formatting, EXCEPT one procedure: the means of recovering. Tab may be physically harder to execute, but putting the cursor before the heading title and hitting tab to shift the heading without shifting its subordinates is highly counter-intutive. Most users would never think of it, expecting that if you move the header, its subordinates go with it. The counter-intuitiveness is even starker when the subordinate isn't a heading but body text belonging to the moved heading, and the new heading accrues new body text. The reason that's more counter-intuitive is that body text is still more intimately associated with a heading than its subordinates. It seems to me the mistake here is not assuming the mindset of the user, who is thinking of topics and subordinates belonging to them and not meaningless lines with tabs. It is true that some clerical workers might take the tab-oriented view, but OneNote is a product for knowledge workers, not their secretaries, right


----- Peter Engrav (MS) wrote: ----

Said geekily "the state of the outline in paragraphs after the one with th
cursor in it should not affect editing behavior"

Hence our current behavior

___

Such a rule would have merit in its simplicity, were there an unequivocal interpretation. But there isn't, because it begs what's really the key question: what constitutes editing behavior? If you take "editing behavior" to mean the sheer geographical positioning of text on the page, you get the current rule. But if you take "editing behavior" as characterized in terms like "creates a heading with the other subordinates as children" versus "creates a heading with out children, then you get the "suggested" rule. This is the nub of the question--to make the program intuitive do you think through the rules in terms of the units salient in the process of outlining or in terms of arbitrary conventions manipulating lines of symbols? If you are writing a program for knowledge workers and not primarily their secretaries, I think you do best to analyze the programs procedures in the units that are salient for the activity, not in a least common denominator page-geographical idiom.

 

[Grant Robertson]

Yes, there are various defensible conventions an outliner
could adopt, but that doesn't excuse choosing an
indefensible one. The one thing the user is not primed to
expect is that creating a subordinate immediately
following A would cause A to lose B and C, with the
result that the user could easily reassign B and C
without even knowing it.

I agree. Separating children from their parent with the mere press of an
enter key is pretty indefensible. My main paint is that most of the
outliners I have used have this same problem, and I have been using them
for a long time. I even had one called 'Thought' that came on a ROM chip
and ran on my old Radio Shack Model l00. Using the technique I mentioned
works every time.

 

[Ben M. Schorr, MVP-OneNote]

I agree. Separating children from their parent with the mere press of an
enter key is pretty indefensible. My main paint is that most of the
outliners I have used have this same problem, and I have been using them
for a long time. I even had one called 'Thought' that came on a ROM chip
and ran on my old Radio Shack Model l00. Using the technique I mentioned
works every time.

Ah, in this scenario you're talking about where A *already has* subordinate
points and you go back up to A (before 1.) and hit [enter] which then moves
1. and 2. (children of A) to now be children of B. Yes, that's not the
best way to do that, I agree.

 

[srdiamond]

A consensus

Now if we can convince Peter. .

enter key is pretty indefensible. My main paint is that most of the
outliners I have used have this same problem, and I have been using them
for a long time. I even had one called 'Thought' that came on a ROM chip
and ran on my old Radio Shack Model l00. Using the technique I mentioned
works every time.

Ah, in this scenario you're talking about where A *already has* subordinat
points and you go back up to A (before 1.) and hit [enter] which then move
1. and 2. (children of A) to now be children of B. Yes, that's not th
best way to do that, I agree
-
-Ben
Ben M. Schorr, MVP-OneNot
OneNote FAQ: http://home.hawaii.rr.com/schorr/Computers/OneNoteFAQ.ht
SchorrTech Blog: http://www.thespoke.net/MyBlog/bschorr/MyBlog.asp

 

[Peter Engrav \(MS\)]

The problem is that what you really need to convince me of is that a
majority of OneNote's potential users are expecting "outlining" as the base
schema of all of their notes (as opposed to "list", "list-of-records",
"document with headings and occasional inerjections", "table", etc.). We
have a huge wall of notes taken on paper that we've collected from a bunch
of people and in fact a pretty low fraction of them are "outlines".

Another point of friction is that at some level OneNote's page is in fact
extremely geometric. The fact that you can arrow out of your outline onto
the page and put stuff just any-old where, for example. Or the fact that if
you're using a pen (and ink) on a TabletPC you're just putting strokes down
wherever you like. In all of these cases (ink especially) we treat the
location of the user's input as primary and the resulting structure (these
strokes are a word, these words are a line, these lines are a paragraph,
this paragraph is indented and hence a child, etc) are all "parsed" by us.
If you change the geometry of the page we have to reparse the structure.
We're sort of forced into this model with ink and with text that's been
"click-and-typed" onto the page. If we choose the "opposite" model of
presuming that enter, tab, etc. should when editing each "flow region" of
text on the page be interpreted in a primarily structural way that leaves
something of a discontinuity in behavior. Which might not be the worst
thing in the world, but it's not good.

But the truth is this shouldn't be about y'all convincing me or vice versa.
For one thing, it's way to early in the life of OneNote to have given up on
somehow coming up with solutions that work for everyone involved. And if
that doesn't work and it really does boil down to arguing about what users
expect we should just build the appropriate user research and go find out.
So how's this. In the process of designing the next release we're certainly
going to be thinking long and hard about outlines vs. other sorts of note
structure and keyboard editing model. I will make sure that we include in
our usability studies and other such research questions designed to measure
the prevelence of "outlines" (parent/child relationships) in users notes and
their expectations in a variety of situations like those we've been
discussing. Perhaps I'm complete off in the weeds and they'll prove ya'll
are exactly right. OK?

As far as "works for everyone" thinking - one possibilty is that we seperate
the notion that one element is subordinate to another from the notion of
"indent level". The two are still highly corrolated of course but it's now
the case that there are two different models that look like this ..

A
B

.... one of which has A and B as siblings but B has been indented (thinking
of indentation as "formatting") and the other of which has B as a child of A
(and is bound to some form of display rules that say that "being a child of"
should be represented as "indented from").

So far I have no idea what the user did to specify their expectations.
Maybe they had to take some some kind of "Insert Outline" step (rather like
Insert Table)?

This is nice in another direction as well - namely that we've found plenty
of cases where one wants parent child relationships (and perhaps features
like collapse) without that implying indentation. For example, I have many
pages of notes that are really just paragraphs of text with an occasional
"heading" paragraph. I'd love to collapse the headings, but I don't really
want the headings "outdented". I want them rendered in big bold fonts.

What do ya'll think about having to specify "Insert Outline" or "Treat As
Outline" or choose an "Outline" stationary or something like that? Downside
is of course that it means a somewhat tedious little set-up step happens
every so often. Upside is that thereafter we have a happy little "Outline"
island in which we can specify all kinds of "niche" UI.

- PEter

A consensus?

Now if we can convince Peter. . .


----- Ben M. Schorr" <Ben M. Schorr>, "MVP-One wrote: -----

press of an
enter key is pretty indefensible. My main paint is that most of the
outliners I have used have this same problem, and I have been using them
for a long time. I even had one called 'Thought' that came on a ROM chip
and ran on my old Radio Shack Model l00. Using the technique I mentioned
works every time.

Ah, in this scenario you're talking about where A *already has* subordinate
points and you go back up to A (before 1.) and hit [enter] which then moves
1. and 2. (children of A) to now be children of B. Yes, that's not the
best way to do that, I agree.
--
-Ben-
Ben M. Schorr, MVP-OneNote
OneNote FAQ: http://home.hawaii.rr.com/schorr/Computers/OneNoteFAQ.htm
SchorrTech Blog: http://www.thespoke.net/MyBlog/bschorr/MyBlog.aspx

 

[Grant Robertson]

What do ya'll think about having to specify "Insert Outline" or "Treat As
Outline" or choose an "Outline" stationary or something like that? Downside
is of course that it means a somewhat tedious little set-up step happens
every so often. Upside is that thereafter we have a happy little "Outline"
island in which we can specify all kinds of "niche" UI.

Peter, it's great that you are taking such a personal interest in this
issue. I have been using outliners in various forms since about 1986. I
stuck with WordPerfect on an Amiga well into 1995 just because it's
outliner was better than Word's. When Word finally did get a better
outliner I switched platforms completely, primarily to use it's outliner.
I think in outlines, everything I write is in an outline format in one
way or another. However, I have to admit, I think I am an exception.
Almost everyone I know seems to think and write in chunks rather than
organized outlines. Sometimes they want to name those chunks (headings)
but the most important thing is to keep the chunks separate and be able
to rearrange them easily. This is why it was such a problem when the
Insert Space feature mashed things together. (Thankfully, that seems to
be fixed.) Now you just need to make sure that writing guides don't get
scrunched together when we add more text to a writing guide higher up on
the page.

While most people don't realize it, (though I'm sure you do) Word already
allows for the rich variation in combinations of outline and indent
styles that you describe. Personally, I think if people really want to
have that kind of power and flexibility they should just use Word. If
people really want to use these features within OneNote's tabbed
interface then the incorporation of OLE will easily solve that problem.

As you might imagine, I participate in lots of different newsgroups about
many different applications. I have noticed that the applications where
the developers try to make everyone happy eventually become so bloated
that they are almost unusable. They will definitely have lots of devoted
users but those users just get to where they are asking for more and more
special features where the application is practically reading their mind.
In one newsgroup someone complaining about how the Save As dialog opened
with the file name selected by default actually asked that the dialog be
modified so that the cursor was always placed after the 4th character so
he could insert something there that he always does. As if, since he does
it, then everyone must do it.

In my experience supporting real users all these years I have also
learned that most regular people will not use any of these kinds of
special features. A lot of people still use spaces and the enter key for
all of their formatting. They don't even know what indent really means or
does. All they know is that they want the text to show up "There". This
is why the new Click-n-Type feature in Word is so helpful to them.

As I said before, I am a heavy user of the outlining features in OneNote.
I am completely content with the way the indent and outline part of it
works right now. Maybe it is because I have used outliners for so many
years. Maybe it is because I know enough about computers to not expect
them to read my mind. Heck, most of the 'mind reading' features your
colleagues at Microsoft added to Word just frustrate most of the people I
know.

I sincerely believe that most of the extra features that people are
requesting for OneNote can be better addressed by the incorporation of
OLE, VBA, and a strong API rather than bloating it up with a long list of
individual additions. If someone wants a table they can insert a
spreadsheet. If they want a diagram they can embed something from a real
diagramming program. If you try to add all the different things that
people want you will be reinventing every wheel ever made and it will
take an hour and a half to open the program.

Always remember the original design goal of OneNote: easily taking notes.
Formatted output should be the last thing on your mind. Make it easier
and cleaner to export to Word and let people do their final formatting
there.

I've written enough for today. I have to go call my mother for Mother's
Day. I will write later with my list of the things I really think need to
be improved to make it easier for regular people to use it to take their
daily notes.

 

[srdiamond]

What do ya'll think about having to specify "Insert Outline" or "Treat As
Outline" or choose an "Outline" stationary or something like that? Downside
is of course that it means a somewhat tedious little set-up step happens
every so often. Upside is that thereafter we have a happy little "Outline"
island in which we can specify all kinds of "niche" UI

I like this idea a lot. It seems to me there are two potential types of customer for OneNote--1) those interested primarily in a free form database and 2) those with a strong need for a good outliner. In a way, Word proves that a word processor is probably not the best location for the most powerful outliner, although strong outlining is a necessary component of a top word processor. The outline of a word processor must be part of a printable document, but this isn't the case in the best outliners, where levels of analysis deeper than 9 may be pursued by hoisting headers. It doesn't matter that you may never see the outline as a whole

I think outlining processors are experiencing a renaissance, after some setbacks in the 90s, and OneNote is as well-positioned as any product to assume the mantle of _the_ outliner. Its only real potential competitor on Windows is a program called ADM, but for its power, that program is remarkably unpopular. Judging by my reaction, its unprofessional appearance and ugly aesthetics may be the main reason, and OneNote looks cool.

But OneNote is not the killer outliner at its present level of development, which surpasses Word but not by a lot. Using outlines extensively, deeply, and rigorously is a specialized form of notetaking, although it becomes more important as you move from the periphery to the center of the knowledge professions. Outlining conventions will be confusing to those who use the product in a different way, e.g. geographically. Never having used a tablet PC, I'm not in a position to analyze its best practices, but I can see how the geography of the page would be more important

As to bloat, I think users appreciate the ability to alter a whole range of related settings with a single click. Still, maybe those who have no use for the outlining settings could have the option of not installing them. Maybe you could even sell outlining as a separate add-on package. But now I'm out of my depth.

 

[Ben M. Schorr, MVP-OneNote]

As you might imagine, I participate in lots of different newsgroups
about many different applications. I have noticed that the applications
where the developers try to make everyone happy eventually become so
bloated that they are almost unusable. They will definitely have lots
of devoted users but those users just get to where they are asking for
more and more special features where the application is practically reading their mind.

There is a saying at Microsoft: "Designing Microsoft Office is like ordering
pizza for a million people." It's really true, you have SO MANY different
people who want different things; many times opposite things, that ultimately
you just can't produce a product that is going to be perfect for everybody.

With OneNote I think they've started out trying to make the best pepperoni,
best vegetarian and best supreme they could. They'll get to the anchovies
later. (hopefully MUCH later <g>)

 

[Chris_Pratley \(MS\)]

We're not really trying to be an "outliner" - there aren't all that many
people who do real outlining we've found. Collecting chunks of stuff and
making lists is far more universal.

But we're not averse to making outlining pleasant - we even have the outline
toolbar. We might consder havign a special "outline" you can insert or
format a list as that behaves more as you describe for the hardcore
outliners out there.

Question for you and any others - can you explain why "hoisting" is useful
to you, more so than just expanding an outline and scrolling to the part you
want to see? What's the killer scenario for hoisting that you can't do any
other way? (and I don't mean just to work around some old app's limitation
of 9 levels )

Chris Pratley (MS)
OneNote design team

What do ya'll think about having to specify "Insert Outline" or "Treat As
Outline" or choose an "Outline" stationary or something like that? Downside
is of course that it means a somewhat tedious little set-up step happens
every so often. Upside is that thereafter we have a happy little "Outline"
island in which we can specify all kinds of "niche" UI.

I like this idea a lot. It seems to me there are two potential types of

customer for OneNote--1) those interested primarily in a free form database
and 2) those with a strong need for a good outliner. In a way, Word proves
that a word processor is probably not the best location for the most
powerful outliner, although strong outlining is a necessary component of a
top word processor. The outline of a word processor must be part of a
printable document, but this isn't the case in the best outliners, where
levels of analysis deeper than 9 may be pursued by hoisting headers. It
doesn't matter that you may never see the outline as a whole.

I think outlining processors are experiencing a renaissance, after some

setbacks in the 90s, and OneNote is as well-positioned as any product to
assume the mantle of _the_ outliner. Its only real potential competitor on
Windows is a program called ADM, but for its power, that program is
remarkably unpopular. Judging by my reaction, its unprofessional appearance
and ugly aesthetics may be the main reason, and OneNote looks cool.

But OneNote is not the killer outliner at its present level of

development, which surpasses Word but not by a lot. Using outlines
extensively, deeply, and rigorously is a specialized form of notetaking,
although it becomes more important as you move from the periphery to the
center of the knowledge professions. Outlining conventions will be confusing
to those who use the product in a different way, e.g. geographically. Never
having used a tablet PC, I'm not in a position to analyze its best
practices, but I can see how the geography of the page would be more
important.

As to bloat, I think users appreciate the ability to alter a whole range

of related settings with a single click. Still, maybe those who have no use
for the outlining settings could have the option of not installing them.
Maybe you could even sell outlining as a separate add-on package. But now
I'm out of my depth.

 

[Grant Robertson]

But we're not averse to making outlining pleasant - we even have the outline
toolbar. We might consder havign a special "outline" you can insert or
format a list as that behaves more as you describe for the hardcore
outliners out there.

Please do not create special 'islands' of outline behaviour. People have
a hard enough time keeping track of whether their ink is being treated as
handwriting or as a drawing. I would not want yet another type of special
behaviour to keep track of. Remember, the little corner indicators do not
show up unless the item is selected. As I go back and forth in my notes I
would not want to have to remember, "Did I set that to 'Special Outline
Mode' or did I just leave it in 'Regular Semi-Outline Mode'? What was it
again that I couldn't do in 'Special Outline Mode' that I can do in
'Regular Semi-Outline Mode'?" or "Oh crap, I forgot to set this paragraph
to 'Special Outline Mode' before I wrote all my notes. Now, if I change
the setting, it will mess up this and rearrange that and I might get
confused because this is three pages of notes and I can't see it all at
the same time so I won't know what gets affected and how. Oh well, I
guess I will just leave it the way it is and have to remember that it is
only in the 'Regular Semi-Outline Mode' so I have to remember to only
modify it thus and such way....."

Now I may be able to keep track but a regular user never would. They
would just never use the 'Special Outline Mode'.

Those who did use the 'Special Outline Mode' would just be encouraged to
keep asking for more and more features. Pretty soon they would be
clamoring for things like being able to rearrange the order in which the
note flags appear. Then rearranging them for each individual item because
they have developed some intricate system for keeping track of what still
needs to be done about something by special note flags and they NEED to
be able to see the order in which those tasks must be accomplished by
looking at the note flag icons alone. Then will come the requests for
special database fields to attach to each outline item. Then they will
absolutely HAVE to be able to do math using these fields from multiple
different items. Then inheritance of flags from parent to child. And
filtering of the display based on note flags. Then spreadsheet type
functions for the special user fields which will then have to have unique
names ala named cells in Excel............ It will NEVER end! If you
think I am imagining things just take a look at
http://groups.yahoo.com/group/shadow-discuss/. And these people want to
be able to do all of this on a 2" wide screen for cry'un out loud.

Again, the solution for all of this is the holy trinity of acronyms for
functionality and interopability in Microsoft Office products: API, OLE,
& VBA. Just treat the linked or embedded objects the same way you do
pictures now. Let them be indented and drug around by the handle just
like a paragraph or inserted in line with the text of another paragraph.
Other than that, let the OLE server app take care of it. Then, if people
want all those special fields they can just link or embed a piece of a
Microsoft Project file. What's that, they can't afford Microsoft Project?
Well then so sad, too bad! What do they want, the entire Office
productivity suite included in one $100 product?


If you want to modify the way outlines are handled when we press the
enter key in certain locations, that would be fine.... I guess. As I've
said before, I have been outlining for a very long time and it works just
fine for me. Adding the one special case so that pressing enter at the
end of an item with children would not separate it from it's children
might be OK. But you still have the dilemma over what should happen.
Should it create a new child and put it above the other children? Lots of
people would complain about this because it would screw up their list of
steps. Should it add a new child and put it at the end of the list of
children? Some people wouldn't like that either because what if the last
child has children of it's own? Should it then go after all of those
grandchildren but at the level of the parent's direct children?

Many people would say that both of these are wrong because the cursor was
at the parent's outline level so the new paragraph created should also be
at the parent's outline level. In a way, this kinda, sorta makes the most
sense. You could say that pressing enter with the cursor at the end of a
line ALWAYS creates a new paragraph at that SAME outline level regardless
of the presence or absence of children. This would also be consistent
with the behaviour one would expect if the current item had children but
they were all collapsed at the time you pressed the enter key. However,
there would still be some people complaining because they had three pages
of children and grandchildren and they did not expect pressing the enter
key to suddenly jump them down three pages.

I really think the best solution is to just leave it alone. Make it clear
in the help file and beginners tutorials that pressing enter with the
cursor at the end of any line will create a new paragraph at the SAME
LEVEL of the current one and DIRECTLY UNDER it. If they want anything
else then they can just put the cursor somewhere else before they press
the darn enter key or just move it around after they have created the new
paragraph. It's not that darn difficult!

For people who are really in a hurry and don't want their hands to leave
the keyboard you might want to create some more hot keys for moving
things around in the outline. Currently, the [Tab] and [Shift-Tab] hot
keys only work as expected if the cursor is at the beginning of a
paragraph. Plus there are some people who want to be able to use a
regular tab at the beginning of the paragraph to indent the first line.
Here is what I propose. Use the Alt modifier with the arrow keys to move
paragraphs up, down, left, and right. I have tried it and holding the Alt
modifier down while pressing the arrow keys currently does nothing so
that is the perfect, easy to remember, hot key to use. Having hot keys
that always work as expected regardless of where the cursor is in the
paragraph would really speed up typed note taking for many people.

 

[srdiamond]

Everybody wants more features, but many people resent features they don't use as "bloat." Grant, for example, wants more hot keys that operate with greater universality, but doesn't want more outlining commands. I don't need hot keys involving arrow keys because of the way they are placed on my Kinesis Contour keyboard, but want more outlining commands. And so the story goes and has gone with all software that anyone releases

There are two strategies. A developer might refuse to enable features unless they are useful to most users, or a developer can try to accommodate users and hope they appreciate that if everyone is to be satisfied, there will be many features most users have no need. Of course features that are irrelevant to the core purpose should be excluded, but given that proviso, users will not be confused by features they have no need for because users with limited needs don't usually try features they don't understand. (If you don't believe me, consider Word's styles.) If you don't want outlining commands, just leave the default settings

Most of the complaints about feature bloat are really complaints about pricing. People think they are made to pay for features they don't use, not grasping economies of scale. Secondarily, some users blame problems arising from faulty computer maintenance on an application's size