Moin Moin Faq

The term Wiki is a shortened form of WikiWikiWeb. A Wiki
is a database of pages that can be collaboritively edited using a web
browser.

A MoinMoin is a wiki provided by the python wiki program MoinMoin.

To be honest, it is good for whatever you use it for. At
Lineo
we have put up a wiki on our internal web site with
very many pages, which describe various projects, architectures,
ideas, etc. for people to comment on. Some pages just sit there and
convey information. Other pages are an open invitation for discussion
and commentary. We also have set up a wiki for a very simple skills
database.

In general, a wiki is very much a free-form tool, whose
value derives from the use to which it is put. For instance, a page in
a wiki can serve the same purpose as a discussion thread. You could
use a wiki page to collaboratively work on a project.

Wikis are used internally by the guys who write Zope
to manage their ideas and projects.

Here are some important wiki features:

• Editability by anyone - A wiki page is editable by anyone with a web browser
  
• ability to view recent changes
  
• ability to search pages (several ways)
  
• ability to very easily add new pages
  
• ability to see the change history for a document
  
• ability to add new information or modify existing information
  
  

A Wiki can accomplish certain things very easily, but there are
some things it cannot do. The biggest missing
feature is some kind of access control, to allow only certain groups
to see and manipulate informatin.

This is an important question. In general, wiki's have
NO security. (That's right!) Because of this, the
possibility exists for accidental or conscious destruction or corruption
of part of all of the wiki.

There are two main ways to devalue a wiki. One is through erasure
and the other is through corruption. Dealing with erasure is not terribly
difficult, because there is a change log (and back versions) of every page
maintained in a location inaccessible to web users. Thus, when page
deletions or major content erasures are detected (which should be fairly
quickly), pages can be restored quite easily to their previous good state.

Explicit and intentional
corruption is more difficult to deal with. The possibility exists that someone
can enter incorrect information onto a page, or edit pages to intentionally
change the information so it is incorrect (for example, people can change
the attributions on a page to make it look like a different person made a
particular comment, or someone can change the content of a paragraph to
alter its meaning in a detrimental way). Pretty much any collaborative system
has this problem. A Wiki is just more wide open to it, since it lacks
any security at all. In practice, wiki corruption is an extremely rare
event, and one that could be dealt with (if needed) with a notification
feature (to a fixed auditor) for new material submission.

In other words, the philosophy of wiki is one of dealing manually with the
rare (exception) case of a saboteur, rather than designing in features
and overhead (both in implementation and in usage) to avoid the damage
caused by a saboteur.

There are already more ways to search and/or scan the wiki than you
can "shake a stick at":

• Click on the magnifying glass icon. This brings you to the FindPage
  page, where you can search by keyword in title, by full text, with
  normal words or wildcards (regular expressions).
  
• Click on TitleIndex. This will show you an alphabetized list
  of all pages by title.
  
• Click on WordIndex. This shows an alphabetized list of every
  word in every title (ie, the Bluetooth page is under, B, Bluetooth).
  
• Click on ~cpp LikePages at the bottom of the page. This shows pages
  that have words in their titles that are similar to the current page.
  
• Click on the page title at the very top of the page. This
  shows what pages link to the current page (which may help you
  find related pages).
  
  

Click on the RecentChanges link at the top of any page.

Any mixed case name that doesn't have a page will show up as a red link.

If you see something you'd like to comment on, add to, or change,
just click on the EditText link at the bottom of the page, or click on
the icon at the top of the page. The page is brought
up in a text-edit pane in your browser, and you simply make the changes.
The wiki formatter will generally "do the right thing" with any text
you enter. If you want to get fancy, you can do most of the same types
of formatting that html allows you to do. See the HelpOnFormatting page for some tips and examples.

Not very many. It helps to keep certain types of information
formatted in a consistent way. One important
convention that will help with consistency is the use of "Template"
pages.

The wiki has a feature called "Templates" which show up when you
create a new page. If you click on one of
these when creating a new page, then that page will have a structure
similar to others of the same type. For example, when creating your own Wiki
homepage, you should use the HomepageTemplate page, which is available when
you create a new page in the wiki.

A. If the content already exists on a web site, then just add
a link to a wiki page. Follow these steps:

• Get the URL for the document,
  
• Edit the Wiki page (go to the Wiki page and click the EditText link)
  
• Type in the URL where you want it in the document
  
• Save the changes.
  

The wiki will automatically make a hypertext link from the text you
type in.

You can make the link "prettier" by putting "cover" wording for the
link in brackets. The cover wording will appear on the page, but the
link will take the user to the URL when clicked on. Here's an example:

~cpp 
  [http://your.link.here/foo.html This will be the link text]

produces:

This will be the link text

You can include a url to the image in the page. Example:

~cpp 
http://www.lineo.com/images/products/uclinux/logo_small.gif

produces

If they are significant, or you want people to know that you made them,
then yes. Just put your name or email address after your comment. It is
not uncommon to indent your comment under the statement your are commenting
on. Also, it helps to italicize your comment to make it stand off
from the main body of the page you are commenting on.

However, in some cases it may be appropriate to just make your change
anonymously. Correcting spelling, formatting, or trivial word changes
are some examples where it is not necessary (and even discouraged) for
you to sign your modification.

A. If you want to add a single line of HTML, use the HTML macro.
This is done by putting your html text as a parameter to the
HTML macro, like so:

~cpp [[HTML(<font size=+12>This is large font</font>)]]

This would show up on the page as:
This is large font

It's also possible to place an html document into a page by adding
~cpp #format html
as the first line in the page. If that line is there then the whole
page will be interpreted as HTML (thus making links to other pages
becomes a bit more difficult!) Make sure that you only add the body
portion of the page (not the HTML headers or anything else outside
of the body, including the <BODY> tag itself).

Diffs need two things to work properly:

• The directory "datadir~cpp /backup" must exist.
  
• You need a GNU diff executable in your webserver's PATH. Note that the PATH of your webserver might be much shorter than the PATH you are used to from your shell.
  
  

"DeletePage" is not active by default, since it's most often used in intranets only and is somewhat dangerous in public wikis. To allow this and other dangerous actions, add them like this to ~cpp moin_config.py:

~cpp 
allowed_actions=['DeletePage']

There is a lot of administration information on the RecentChanges page,
including the number of pages, and the macros and actions that are installed.

I usually set up an "AdminPage", where I put macros for
these, as well as information about the real physical location of the
pages, and macros for orphan pages or other things an adminstrator
for the wiki might want to look at.

Not directly. It's easy to do (if you have permissions where
the actual wiki data files are kept. But usually, you must
request the wiki administrator to restore the page for you.
This is done as a hedge against the
improbable case of someone trying to sabotage the wiki.

For people reading this FAQ page (which is probably not your average attacker), there is this way to restore a page:

1. click on the little "i" in the top-right corner (~cpp PageInfo).
   
2. click on "view" of the version you want to restore.
   
3. in the "Location" bar of your browser, replace "action=recall" with "action=raw".
   
4. Cut&paste the text into the edit box of that page, after clicking "~cpp EditPage".
   
   

Templates are pages that show up automatically as options when you
create a blank page. Any page that ends in the word Template will
automatically show up in the list. Hence, if you want certain
types of pages to have a similar format (similar headings, organization,
etc.), you just define a page that ends in Template, and when creating
pages of this type, select that template and edit it. The wiki
fills in the starting content for you. Templates are editable wiki
pages like any other.

To create a Template page, just create a new page called <something>Template