Merge branch 'master' of orgmode.org:worg

dev/index.org

@@ -14,6 +14,47 @@
 This page gather links to reference documentation and (forthcoming)
 tutorials on how to extend Org.
 
+* Git workflow
+
+As of March 20th (see [[http://article.gmane.org/gmane.emacs.orgmode/53608/match%3Dnew%2Bgit%2Bworkflow][this email]]), Org development uses a three-branches
+git workflow.
+
+- master :: This branch contains latest development for Org.  Temporary
+            feature branch (either local or remote) should branch out from
+            this branch.  This branch is merged to the =maint= branch when
+            there is a major release.
+
+- maint :: This branch is the "production" branch for Org.  It contains
+           only releases.  No branch should branch out from it, and it is
+           *never* merged into another branch.  The Org version on this
+           branch is the one regularily sync'ed with Emacs repository.
+
+- hotfix-7.8.06 :: This branch is the hotfix branch for the latest release.
+
+** Future changes
+
+In the near future, the =maint= branch will probably be renamed =release=
+and the =hotfix-7.8.06= will probably be renamed =hotfix=.  The role of the
+branches won't change.
+
+** Git repositories
+
+The git repository for Org is on =orgmode.org=: 
+
+- http://orgmode.org/w/org-mode.git
+
+This repository is cloned on =repo.or.cz=:
+
+- http://repo.or.cz/w/org-mode.git
+
+You can display a graphic representation of the branches here:
+
+- http://repo.or.cz/git-browser/by-commit.html?r=org-mode.git
+
+# * TODO Merging into Emacs repository
+
+# We try to merge Org with Emacs regularily.
+
 * Reference documentation
 
 - [[file:org-export-reference.org][reference documentation]] for the new export engine (=org-export.el=)

dev/org-export-reference.org

@@ -24,8 +24,9 @@ and [[#toolbox][tools]] provided by the exporter.
   :CUSTOM_ID: attributes
   :END:
 
-  Element attributes are accessed with ~org-element-get-property~
-  function.
+  Element attributes are accessed with ~org-element-property~
+  function.  Other accessors relative to elements are
+  ~org-element-type~ and ~org-element-contents~.
 
   In addition to these properties, each element can optionally get
   some more from affiliated keywords, namely: ~:attr_ascii~,
@@ -186,11 +187,30 @@ and [[#toolbox][tools]] provided by the exporter.
                closing line or at buffer's end (integer).
    - ~:hiddenp~ :: Non-nil if block is hidden (symbol:
                    ~org-hide-block~, nil).
+   - ~:label-fmt~ :: Format string used to write labels in current
+                     block, if different from
+                     ~org-coderef-label-format~ (string or nil).
+   - ~:language~ :: Language of the code in the block, if specified
+                    (string or nil).
+   - ~:number-lines~ :: Non-nil if code lines should be numbered.
+        A ~new~ value starts numbering from 1 wheareas ~continued~
+        resume numbering from previous numbered block (symbol: ~new~,
+        ~continued~ or nil).
    - ~:options~ :: Block's options located on the block's opening line
                    (string).
+   - ~:parameters~ :: Optional header arguments (string or nil).
    - ~:post-blank~ :: Number of blank lines between block's closing
                       line and next non-blank line or buffer's end
                       (integer).
+   - ~:preserve-indent~ :: Non-nil when indentation within the block
+        mustn't be modified upon export (boolean).
+   - ~:retain-labels~ :: Non-nil if labels should be kept visible upon
+        export (boolean).
+   - ~:switches~ :: Optional switches for code block export (string or
+                    nil).
+   - ~:use-labels~ :: Non-nil if links to labels contained in the
+                      block should display the label instead of the
+                      line number (boolean).
    - ~:value~ :: Contents (string).
 
 ** Export Block
@@ -511,11 +531,28 @@ and [[#toolbox][tools]] provided by the exporter.
      - ~coderef~ :: Line in some source code,
      - ~custom-id~ :: Specific headline's custom-id,
      - ~file~ :: External file,
-     - ~fuzzy~ :: Target or an headline in the current parse tree,
+     - ~fuzzy~ :: Target, target keyword, a named element or an
+                  headline in the current parse tree,
      - ~id~ :: Specific headline's id,
-     - ~radio~ :: Radio-target,
+     - ~radio~ :: Radio-target.
      It can also be any ~org-link-types~ element.
 
+
+   Notes relative to export:
+
+   - A fuzzy link leading to a target keyword should be ignored during
+     export: it's an invisible target.
+   - A fuzzy link with no description should display the
+     cross-reference number of its target.  This number can be:
+     - If link's destination is a target object within a footnote, it
+       will be footnote's number.
+     - If link's destination is a target object in a list, it will be
+       an item number.
+     - If link leads to a named element, it will be the sequence number
+       of that element among named elements of the same type.
+     - Otherwise, it will be the number of the headline containing
+       link's destination.
+
 ** Macro
 
    Object.
@@ -684,14 +721,28 @@ and [[#toolbox][tools]] provided by the exporter.
                block's closing line or at buffer's end (integer).
    - ~:hiddenp~ :: Non-nil if block is hidden (symbol:
                    ~org-hide-block~ nil).
+   - ~:label-fmt~ :: Format string used to write labels in current
+                     block, if different from
+                     ~org-coderef-label-format~ (string or nil).
    - ~:language~ :: Language of the code in the block, if specified
                     (string or nil).
+   - ~:number-lines~ :: Non-nil if code lines should be numbered.
+        A ~new~ value starts numbering from 1 wheareas ~continued~
+        resume numbering from previous numbered block (symbol: ~new~,
+        ~continued~ or nil).
    - ~:parameters~ :: Optional header arguments (string or nil).
    - ~:post-blank~ :: Number of blank lines between block's closing
                       line and next non-blank line or buffer's end
                       (integer).
+   - ~:preserve-indent~ :: Non-nil when indentation within the block
+        mustn't be modified upon export (boolean).
+   - ~:retain-labels~ :: Non-nil if labels should be kept visible upon
+        export (boolean).
    - ~:switches~ :: Optional switches for code block export (string or
                     nil).
+   - ~:use-labels~ :: Non-nil if links to labels contained in the
+                      block should display the label instead of the
+                      line number (boolean).
    - ~:value~ :: Source code (string).
 
 ** Statistics Cookie
@@ -764,21 +815,23 @@ and [[#toolbox][tools]] provided by the exporter.
 
 ** Target
 
-   Recursive object.
+   Object.
 
    - ~:begin~ :: Buffer position before first /less-than/ opening sign
                  (integer).
-   - ~:contents-begin~ :: Buffer position after last /less-than/
-        opening sign (integer).
-   - ~:contents-end~ :: Buffer position before first /greater-than/
-        closing sign (integer).
    - ~:end~ :: Buffer position before first non-blank character after
                last /greater-than/ closing sign, or at paragraph's end
                (integer).
    - ~:post-blank~ :: Number of white spaces between last
                       /greater-than/ closing sign and next non-blank
                       character or paragraph's end (integer).
-   - ~:raw-value~ :: Uninterpreted contents (string).
+   - ~:value~ :: Target's ID (string).
+
+
+   Notes relatives to export:
+
+   - Target should become an anchor, if back-end permits it.
+   - Target's ID shouldn't be visible on export.
 
 ** Time Stamp
 
@@ -901,14 +954,6 @@ and [[#toolbox][tools]] provided by the exporter.
    - category :: option
    - type :: alist (STRING . LIST)
 
-** ~:genealogy~
-
-   Flat list of current object or element's parents from closest to
-   farthest, along with their contents.
-
-   - category :: local
-   - type :: list of elements and objects
-
 ** ~:headline-levels~
    :PROPERTIES:
    :CUSTOM_ID: headline-levels
@@ -939,6 +984,14 @@ and [[#toolbox][tools]] provided by the exporter.
    - category :: tree
    - type :: integer
 
+** ~:ignore-list~
+
+   List of elements and objects that will be unconditionally ignored
+   during export.
+
+   - category :: option
+   - type :: list of elements
+
 ** ~:input-file~
 
    Full path to input file, if any.
@@ -1157,6 +1210,93 @@ and [[#toolbox][tools]] provided by the exporter.
    - category :: option
    - type :: symbol (nil, t)
 
+* The Filter System
+  :PROPERTIES:
+  :CUSTOM_ID: filter-system
+  :END:
+
+  Filters sets are lists of functions.  They allow to pre-process
+  parse tree before export and to post-process output of each
+  transcoded object or element.
+
+  Each function in a set must accept three arguments: a string (or
+  a parse tree as a special case), a symbol representing the current
+  back-end, and the communication channel, as a plist.
+
+  From the developer side, filters sets can be installed in the
+  process with the help of ~org-BACKEND-filters-alist~ variable.  Each
+  association has a key among the following symbols and a function or
+  a list of functions as value:
+
+  - ~:filter-babel-call~
+  - ~:filter-center-block~
+  - ~:filter-comment~
+  - ~:filter-comment-block~
+  - ~:filter-drawer~
+  - ~:filter-dynamic-block~
+  - ~:filter-emphasis~
+  - ~:filter-entity~
+  - ~:filter-example-block~
+  - ~:filter-export-block~
+  - ~:filter-export-snippet~
+  - ~:filter-final-output~
+  - ~:filter-fixed-width~
+  - ~:filter-footnote-definition~
+  - ~:filter-footnote-reference~
+  - ~:filter-headline~
+  - ~:filter-horizontal-rule~
+  - ~:filter-inline-babel-call~
+  - ~:filter-inline-src-block~
+  - ~:filter-inlinetask~
+  - ~:filter-item~
+  - ~:filter-keyword~
+  - ~:filter-latex-environment~
+  - ~:filter-latex-fragment~
+  - ~:filter-line-break~
+  - ~:filter-link~
+  - ~:filter-macro~
+  - ~:filter-paragraph~
+  - ~:filter-parse-tree~
+  - ~:filter-plain-list~
+  - ~:filter-plain-text~
+  - ~:filter-property-drawer~
+  - ~:filter-quote-block~
+  - ~:filter-quote-section~
+  - ~:filter-radio-target~
+  - ~:filter-section~
+  - ~:filter-special-block~
+  - ~:filter-src-block~
+  - ~:filter-statistics-cookie~
+  - ~:filter-subscript~
+  - ~:filter-superscript~
+  - ~:filter-table~
+  - ~:filter-target~
+  - ~:filter-time-stamp~
+  - ~:filter-verbatim~
+  - ~:filter-verse-block~
+
+
+  For example, =e-ascii= back-end implements a filter that makes sure
+  sections end with two blank lines:
+
+  #+BEGIN_SRC emacs-lisp
+  (defun org-e-ascii-filter-section-blank-lines (headline back-end info)
+    "Filter controlling number of blank lines after a section."
+    (if (not (eq back-end 'e-ascii)) headline
+      (let ((blanks (make-string 2 ?\n)))
+        (replace-regexp-in-string "\n\\(?:\n[ \t]*\\)*\\'" blanks headline))))
+  #+END_SRC
+
+  The filter is then installed with the following:
+
+  #+BEGIN_SRC emacs-lisp
+  (defconst org-e-ascii-filters-alist
+    '((:filter-headline . org-e-ascii-filter-section-blank-lines)
+      (:filter-section . org-e-ascii-filter-section-blank-lines))
+    "Alist between filters keywords and back-end specific filters.
+  See `org-export-filters-alist' for more information.")
+  #+END_SRC
+
 * The Toolbox
   :PROPERTIES:
   :CUSTOM_ID: toolbox
@@ -1264,6 +1404,31 @@ and [[#toolbox][tools]] provided by the exporter.
    See also: [[#get-relative-level][~org-export-get-relative-level~]],
    [[#number-to-roman][~org-export-number-to-roman~]], [[#last-sibling-p][~org-export-last-sibling-p~]].
 
+** ~org-export-format-code~
+   :PROPERTIES:
+   :CUSTOM_ID: format-code
+   :END:
+
+   Helper function to format source code.  It applies a given function
+   on each line of the code, passing current line number and
+   associated code reference label, if any, as arguments.
+
+   See also: [[#format-code-default][~org-export-format-code-default~]], [[#get-loc][~org-export-get-loc~]],
+   [[#unravel-code][~org-export-unravel-code~]].
+
+** ~org-export-format-code-default~
+   :PROPERTIES:
+   :CUSTOM_ID: format-code-default
+   :END:
+
+   Return contents of a =src-block= or =example-block= element in
+   a format suited for raw text or verbatim output.  More
+   specifically, it takes care of line numbering and labels
+   integration depending of element's switches, but no formatting is
+   otherwise applied to source code.
+
+   See also: [[#format-code][~org-export-format-code~]], [[#unravel-code][~org-export-unravel-code~]].
+
 ** ~org-export-footnote-first-reference-p~
    :PROPERTIES:
    :CUSTOM_ID: footnote-first-reference-p
@@ -1314,6 +1479,19 @@ and [[#toolbox][tools]] provided by the exporter.
    [[#footnote-first-reference-p][~org-export-footnote-first-reference-p~]],
    [[#get-footnote-definition][~org-export-get-footnote-definition~]].
 
+** ~org-export-get-genealogy~
+   :PROPERTIES:
+   :CUSTOM_ID: get-genealogy
+   :END:
+
+   Return flat list of current object or element's parents from
+   closest to farthest, along with their contents.
+
+   See also: [[#get-next-element][~org-export-get-next-element]], [[#get-parent][~org-export-get-parent]],
+   [[#get-parent-headline][~org-export-get-parent-headline~]],
+   [[#get-parent-paragraph][~org-export-get-parent-paragraph~]],
+   [[#get-previous-element][~org-export-get-previous-element~]].
+
 ** ~org-export-get-headline-number~
    :PROPERTIES:
    :CUSTOM_ID: get-headline-number
@@ -1321,7 +1499,23 @@ and [[#toolbox][tools]] provided by the exporter.
 
    Return the section number of an headline, as a list of integers.
 
-   See also: [[#number-to-roman][~org-export-number-to-roman~]].
+   See also: [[#headline-numbered-p][~org-export-headline-numbered-p~]],
+   [[#number-to-roman][~org-export-number-to-roman~]].
+
+** ~org-export-get-loc~
+   :PROPERTIES:
+   :CUSTOM_ID: get-loc
+   :END:
+
+   Return count of accumulated lines of code from previous
+   line-numbered =example-block= and =src-block= elements, according
+   to current element's switches.
+
+   In other words, the first line of code in the current block is
+   supposed to be numbered as the returned value plus one, assuming
+   its ~:number-lines~ properties is non-nil.
+
+   See also: [[#format-code][~org-export-format-code~]], [[#unravel-code][~org-export-unravel-code~]].
 
 ** ~org-export-get-next-element~
    :PROPERTIES:
@@ -1331,27 +1525,84 @@ and [[#toolbox][tools]] provided by the exporter.
    Return element (resp. object or string) after an element
    (resp. object), or nil.
 
-   See also: [[#get-previous-element][~org-export-get-previous-element~]],
-   [[#get-parent-headline][~org-export-get-parent-headline~]].
+   See also: [[#get-genealogy][~org-export-get-genealogy~]], [[#get-parent][~org-export-get-parent~]],
+   [[#get-parent-headline][~org-export-get-parent-headline~]],
+   [[#get-parent-paragraph][~org-export-get-parent-paragraph~]],
+   [[#get-previous-element][~org-export-get-previous-element~]].
 
 ** ~org-export-get-ordinal~
+   :PROPERTIES:
+   :CUSTOM_ID: get-ordinal
+   :END:
 
-   Associate a sequence number to any object or element.
+   Associate a sequence number to any object or element.  It is meant
+   to be used to build captions.
+
+   Also, it could be applied on a fuzzy link's destination, since such
+   links are expected to be replaced with the sequence number of their
+   destination, provided they have no description.
+
+   Taken from =e-ascii= back-end, the following example shows how
+   fuzzy links could be handled :
+
+   #+BEGIN_SRC emacs-lisp :exports code
+   (let ((type (org-element-property :type link)))
+     (cond
+      ...
+      ;; Do not apply a special syntax on fuzzy links pointing to targets.
+      ((string= type "fuzzy")
+       (let ((destination (org-export-resolve-fuzzy-link link info)))
+         ;; Ignore invisible "#+TARGET: path".
+         (unless (eq (org-element-type destination) 'keyword)
+           ;; If link has a description, use it.
+           (if (org-string-nw-p desc) desc
+             (when destination
+               (let ((number (org-export-get-ordinal destination info)))
+                 (when number
+                   (if (atom number) (number-to-string number)
+                     (mapconcat 'number-to-string number ".")))))))))
+      ...))
+   #+END_SRC
+
+   See also : [[#resolve-fuzzy-link][~org-export-resolve-fuzzy-link~]]
+
+** ~org-export-get-parent~
+   :PROPERTIES:
+   :CUSTOM_ID: get-parent
+   :END:
 
-   This isn't appropriate for footnotes references, whose sequence
-   isn't always linear.  In that case, use
-   [[#get-footnote-number][~org-export-get-footnote-number~]] instead.
+   Return closest element containing current element or object, if
+   any.  Return nil otherwise.
+
+   See also: [[#get-genealogy][~org-export-get-genealogy~]],
+   [[#get-next-element][~org-export-get-next-element~]], [[#get-parent-paragraph][~org-export-get-parent-paragraph~]],
+   [[#get-parent-headline][~org-export-get-parent-headline~]],
+   [[#get-previous-element][~org-export-get-previous-element~]].
 
 ** ~org-export-get-parent-headline~
    :PROPERTIES:
-   :CUSTOM_ID: #get-parent-headline
+   :CUSTOM_ID: get-parent-headline
    :END:
 
    Return the headline containing provided element or object, if any.
    Return nil otherwise.
 
-   See also: [[#get-previous-element][~org-export-get-previous-element~]],
-   [[#get-next-element][~org-export-get-next-element~]].
+   See also: [[#get-genealogy][~org-export-get-genealogy~]],
+   [[#get-next-element][~org-export-get-next-element~]], [[#get-parent][~org-export-get-parent]],
+   [[#get-parent-paragraph][~org-export-get-parent-paragraph~]],
+   [[#get-previous-element][~org-export-get-previous-element~]].
+
+** ~org-export-get-parent-paragraph~
+   :PROPERTIES:
+   :CUSTOM_ID: get-parent-paragraph
+   :END:
+
+   Return the paragraph containing provided object, if any.  Return
+   nil otherwise.
+
+   See also: [[#get-genealogy][~org-export-get-genealogy~]], [[#get-parent][~org-export-get-parent~]],
+   [[#get-parent-headline][~org-export-get-parent-headline~]],
+   [[#get-previous-element][~org-export-get-previous-element~]], [[#get-next-element][~org-export-get-next-element~]].
 
 ** ~org-export-get-previous-element~
    :PROPERTIES:
@@ -1361,8 +1612,10 @@ and [[#toolbox][tools]] provided by the exporter.
    Return element (resp. object or string) before an element
    (resp. object), or nil.
 
-   See also: [[#get-next-element][~org-export-get-next-element~]],
-   [[#get-parent-headline][~org-export-get-parent-headline~]].
+   See also: [[#get-genealogy][~org-export-get-genealogy~]],
+   [[#get-next-element][~org-export-get-next-element~]], [[#get-parent][~org-export-get-parent~]],
+   [[#get-parent-headline][~org-export-get-parent-headline~]],
+   [[#get-parent-paragraph][~org-export-get-parent-paragraph~]].
 
 ** ~org-export-get-relative-level~
    :PROPERTIES:
@@ -1373,16 +1626,19 @@ and [[#toolbox][tools]] provided by the exporter.
    the parsed tree.  It is meant to be used over ~:level~ headline's
    property.
 
-   See also: [[#get-headline-number][~org-export-get-headline-number~]],
-   [[#first-sibling-p][~org-export-first-sibling-p~]], [[#last-sibling-p][~org-export-last-sibling-p~]].
+   See also:[[#first-sibling-p][~org-export-first-sibling-p~]],
+    [[#get-headline-number][~org-export-get-headline-number~]],[[#headline-numbered-p][~org-export-headline-numbered-p~]],
+    [[#last-sibling-p][~org-export-last-sibling-p~]].
 
-** ~org-export-handle-code~
+** ~org-export-headline-numbered-p~
+   :PROPERTIES:
+   :CUSTOM_ID: headline-numbered-p
+   :END:
 
-   Update line numbering and clean references in source code, when
-   appropriate.  It can also add text properties to format source code
-   only after some processing.
+   Non nil when a given headline should be numbered.
 
-   See also: [[#resolve-coderef][~org-export-resolve-coderef~]].
+   See also: [[#get-headline-number][~org-export-get-headline-number~]],
+   [[#get-relative-level][~org-export-get-relative-level~]].
 
 ** ~org-export-inline-image-p~
    :PROPERTIES:
@@ -1390,7 +1646,8 @@ and [[#toolbox][tools]] provided by the exporter.
    :END:
 
    Non-nil when the link provided should be considered as an inline
-   image.
+   image.  It also accepts an optional set of rules in order to tweak
+   the definition of an inline image.
 
    See also: [[#solidify-link-text][~org-export-solidify-link-text~]],
    [[#get-coderef-format][~org-export-get-coderef-format~]], [[#resolve-fuzzy-link][~org-export-resolve-fuzzy-link~]].
@@ -1424,8 +1681,8 @@ and [[#toolbox][tools]] provided by the exporter.
    :END:
 
    Search for a code reference within ~src-block~ and ~example-block~
-   elements.  Return corresponding –possibly accumulated— line number,
-   or reference itself, depending on container's switches.
+   elements.  Return corresponding --possibly accumulated-- line
+   number, or reference itself, depending on container's switches.
 
    See also : [[#get-coderef-format][~org-export-get-coderef-format~]],
    [[#resolve-id-link][~org-export-resolve-id-link~]], [[#resolve-fuzzy-link][~org-export-resolve-fuzzy-link~]].
@@ -1439,7 +1696,7 @@ and [[#toolbox][tools]] provided by the exporter.
    attribute – within the parsed tree, and return that element,
    object, or nil.
 
-   See also: [[#resolve-coderef][~org-export-resolve-coderef~]],
+   See also: [[#get-ordinal][~org-export-get-ordinal~]], [[#resolve-coderef][~org-export-resolve-coderef~]],
    [[#resolve-id-link][~org-export-resolve-id-link~]], [[#solidify-link-text][~org-export-solidify-link-text~]].
 
 ** ~org-export-resolve-id-link~
@@ -1454,6 +1711,22 @@ and [[#toolbox][tools]] provided by the exporter.
    See also : [[#resolve-coderef][~org-export-resolve-coderef~]],
    [[#resolve-fuzzy-link][~org-export-resolve-fuzzy-link~]], [[#solidify-link-text][~org-export-solidify-link-text~]].
 
+** ~org-export-unravel-code~
+   :PROPERTIES:
+   :CUSTOM_ID: unravel-code
+   :END:
+
+   Clean source code from an =example-block= or a =src-block= element
+   and extract code references out of it.
+
+   Its purpose is to allow to transform raw source code first and then
+   integrate line numbers or references back into the final output.
+   That final task can be achieved with the help of
+   ~org-export-format-code~ function.
+
+   See also: [[#format-code][~org-export-format-code~]],
+   [[#format-code-default][~org-export-format-code-default~]], [[#get-loc][~org-export-get-loc~]].
+
 ** ~org-export-solidify-link-text~
    :PROPERTIES:
    :CUSTOM_ID: solidify-link-text

org-contrib/babel/languages.org

@@ -52,7 +52,7 @@ language documentation.
 | Org            |                      | org             | none                                        |
 | OZ             | [[file:languages/ob-doc-oz.org][ob-doc-oz]]            | oz (contrib)    | [[http://www.mozart-oz.org/][Mozart]] which includes a major mode          |
 | Perl           |                      | perl            | [[http://www.perl.org/][perl]], [[http://www.emacswiki.org/emacs/CPerlMode][cperl-mode]] (optional)                 |
-| Picolisp       |                      | l (contrib)     | Picolisp                                    |
+| Picolisp       | [[file:languages/ob-doc-picolisp.org][ob-doc-picolisp]]      | picolisp        | [[http://picolisp.com/5000/!wiki?home][PicoLisp]]                                    |
 | PlantUML       |                      | plantuml        |                                             |
 | Python         |                      | python          | [[http://www.python.org/][python]], [[https://launchpad.net/python-mode][python-mode]] (optional)              |
 | R              | [[file:languages/ob-doc-R.org][ob-doc-R]]             | R               | [[http://www.r-project.org/][R]], [[http://ess.r-project.org/][ess-mode]], [[http://cran.r-project.org/web/packages/tikzDevice/index.html][tikzDevice]]                     |

org-contrib/babel/languages/ob-doc-C.org

@@ -7,6 +7,8 @@
 #+EMAIL:      schulte.eric at gmail dot com, davison at stats dot ox dot ac dot uk
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 * Introduction
 Babel can evaluate C and C++ code.  As opposed to interpreted

org-contrib/babel/languages/ob-doc-LaTeX.org

@@ -7,7 +7,7 @@
 #+EMAIL:      tsd [at] tsdye [dot] com
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
-#+LINK_UP:    ../languages.php
+#+LINK_UP:    ../languages.html
 #+LINK_HOME:  http://orgmode.org/worg/
 #+EXPORT_EXCLUDE_TAGS: noexport
 
@@ -76,11 +76,6 @@ page is a bitmap image generated from a simple LaTeX source code
 block.  The complex example provided by [[Andreas%20Leha][Andreas
 Leha]], below, uses the TikZ package to create a graphics image.
 
-The
-[[http://orgmode.org/worg/sources/org-contrib/babel/languages/ob-doc-LaTeX.org.html][Org
-Mode source for this web page]] may be accessed with the link
-provided.
-
 * Requirements and Setup
 In order to use LaTeX source code blocks to their full capacity, a
 working LaTeX installation is required.[fn:4] LaTeX systems are

org-contrib/babel/languages/ob-doc-R.org

@@ -7,7 +7,7 @@
 #+EMAIL:      schulte.eric at gmail dot com, davison at stats dot ox dot ac dot uk
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
-#+LINK_UP:    ../languages.php
+#+LINK_UP:    ../languages.html
 #+LINK_HOME:  http://orgmode.org/worg/
 #+EXPORT_EXCLUDE_TAGS: noexport
 
@@ -51,7 +51,6 @@ R source code blocks in Org Mode can be used to create R packages,
 carry out statistical analyses, create graphic displays, and produce
 reproducible research papers.
 
-  - Link to this Org Mode file.
 * Requirements and Setup
 R source code blocks in Org Mode require a working R installation.
 Precompiled binary distributions for Gnu/Linux, Mac OS X, and Windows
@@ -236,55 +235,18 @@ output graphics=.
     - summary
 *** Use ESS to step through evaluation line-by-line
     1. Use C-c ' to visit the edit buffer for your code block
-    2. Use ess-eval-line-and-step to evaluate each line in turn
+    2. Use =ess-eval-line-and-step= to evaluate each line in turn
 
-In addition to ess-eval-line-and-step, there are several other ESS
-functions with names beginning ess-eval-*. They evaluate lines and
+In addition to =ess-eval-line-and-step=, there are several other ESS
+functions with names beginning =ess-eval-*=. They evaluate lines and
 regions in different ways; it's worth looking at their descriptions
 (C-h f).
-
-** LaTeX code from R
-This example summarises a linear regression fit. Usually the Org Mode
-user should not have to be involved in LaTeX code generation, because
-this is the responsibility of Org Mode's LaTeX export engine. In this
-example, neither the printed representation, nor the value of
-=summary(lm(y ~ x))= is tabular, and it would therefore require some
-work to get the information in to an Org Mode table. However, the
-=xtable= package can be used to output a LaTeX table. Using =:results
-latex= as a header argument to the R source code block ensures that
-this is returned as a LaTeX block in the Org Mode buffer and thus can be
-included correctly in LaTex-based export targets.
-
-#+begin_src R :results output latex
-library(xtable)
-x <- rnorm(100)
-y <- x + rnorm(100)
-xtable(summary(lm(y ~ x)))
-#+end_src
-
-#+results:
-#+BEGIN_LaTeX
-% latex table generated in R 2.9.2 by xtable 1.5-5 package
-% Wed Dec  9 17:17:53 2009
-\begin{table}[ht]
-\begin{center}
-\begin{tabular}{rrrrr}
-  \hline
- & Estimate & Std. Error & t value & Pr($>$$|$t$|$) \\ 
-  \hline
-(Intercept) & -0.0743 & 0.0969 & -0.77 & 0.4454 \\ 
-  x & 1.0707 & 0.0923 & 11.60 & 0.0000 \\ 
-   \hline
-\end{tabular}
-\end{center}
-\end{table}
-#+END_LaTeX
 ** Org Mode Output from R
 David Hajage's [[http://cran.r-project.org/web/packages/ascii/index.html][ascii]] R package creates appropriate plain text
 representations of many R objects. It features an option to specify
 that the plain text representations should be in Org format. This can
 be particularly useful for retrieving non-tabular R data structures in
-Org Mode.
+Org Mode for export.
 
 In R:
 #+begin_example 
@@ -332,20 +294,67 @@ In R:
 #+end_example
 
 
- From Org-babel:
-#+begin_src R :results output org
-  library(ascii)
-  options(asciiType="org")
-  ascii(summary(table(1:4, 1:4)))
-#+end_src
-
+The Org Mode source code block specifies =:results org= so the output
+is wrapped in =#+BEGIN_ORG= ... =#+END_ORG=.  This way, arbitrary
+output can be included and easily replaced on subsequent evaluations
+of the source code block.
+
+
+: #+begin_src R :results output org
+:   library(ascii)
+:   options(asciiType="org")
+:   ascii(summary(table(1:4, 1:4)))
+: #+end_src
+:
+: #+results:
+: #+BEGIN_ORG
+: - Number of cases in table: 4 
+: - Number of factors: 2 
+: - Test for independence of all factors:
+:   - Chisq = 12, df = 9, p-value = 0.2133
+:   - Chi-squared approximation may be incorrect
+: #+END_ORG
+
+The results in this case are exported as a nested list structure:
 #+results:
-Loading required package: proto
+#+BEGIN_ORG
 - Number of cases in table: 4 
 - Number of factors: 2 
 - Test for independence of all factors:
   - Chisq = 12, df = 9, p-value = 0.2133
   - Chi-squared approximation may be incorrect
+#+END_ORG
+
+
+The =caption=, =header=, and =include.colnames= options are useful.
+
+
+: #+BEGIN_SRC R :results output org
+:  library(ascii)
+:  a <- runif(100)
+:  c <- "Quantiles of 100 random numbers"
+:  b <- ascii(quantile(a),header=T,include.colnames=T,caption=c)
+:  print(b,type="org")
+:  rm(a,b,c)
+: #+END_SRC
+:
+: #+RESULTS:
+: #+BEGIN_ORG
+: #+CAPTION: Quantiles of 100 random numbers
+: | 0%   | 25%  | 50%  | 75%  | 100% |
+: |------+------+------+------+------|
+: | 0.03 | 0.28 | 0.52 | 0.74 | 1.00 |
+: #+END_ORG
+
+The output exported to HTML can be quite nice.
+
+#+RESULTS:
+#+BEGIN_ORG
+#+CAPTION: Quantiles of 100 random numbers
+| 0%   | 25%  | 50%  | 75%  | 100% |
+|------+------+------+------+------|
+| 0.03 | 0.28 | 0.52 | 0.74 | 1.00 |
+#+END_ORG
 
 ** Graphics Produced by ggplot2
 
@@ -366,6 +375,43 @@ file specified in the =:file= header argument.
   [[file:r/adze_edge_angle.png]]
 #+end_example
 
+** LaTeX code from R
+This example summarises a linear regression fit. Usually the Org Mode
+user should not have to be involved in LaTeX code generation, because
+this is the responsibility of Org Mode's LaTeX export engine. In this
+example, neither the printed representation, nor the value of
+=summary(lm(y ~ x))= is tabular, and it would therefore require some
+work to get the information in to an Org Mode table. However, the
+=xtable= package can be used to output a LaTeX table. Using =:results
+latex= as a header argument to the R source code block ensures that
+this is returned as a LaTeX block in the Org Mode buffer and thus can be
+included correctly in LaTex-based export targets.
+
+: #+begin_src R :results output latex
+: library(xtable)
+: x <- rnorm(100)
+: y <- x + rnorm(100)
+: xtable(summary(lm(y ~ x)))
+: #+end_src
+
+: #+results:
+: #+BEGIN_LaTeX
+: % latex table generated in R 2.9.2 by xtable 1.5-5 package
+: % Wed Dec  9 17:17:53 2009
+: \begin{table}[ht]
+: \begin{center}
+: \begin{tabular}{rrrrr}
+:   \hline
+:  & Estimate & Std. Error & t value & Pr($>$$|$t$|$) \\ 
+:   \hline
+: (Intercept) & -0.0743 & 0.0969 & -0.77 & 0.4454 \\ 
+:   x & 1.0707 & 0.0923 & 11.60 & 0.0000 \\ 
+:    \hline
+: \end{tabular}
+: \end{center}
+: \end{table}
+: #+END_LaTeX
+
 ** =ess-switch-to-end-of-ESS=
  When in an Org Mode R code edit buffer with an associated R session,
  =M-x ess-switch-to-end-of-ESS= will bring the R session buffer into

org-contrib/babel/languages/ob-doc-clojure.org

@@ -7,6 +7,8 @@
 #+EMAIL:      joel dot boehland at evocomputing dot com
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 #+begin_html
   <div id="subtitle" style="float: center; text-align: center;">

org-contrib/babel/languages/ob-doc-gnuplot.org

@@ -7,6 +7,8 @@
 #+EMAIL:      jw[dot]hendy[at]gmail[dot]com
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 #+begin_html
   <div id="subtitle" style="float: center; text-align: center;">

org-contrib/babel/languages/ob-doc-ledger.org

@@ -10,8 +10,8 @@
 #+INFOJS_OPT: view:nil toc:nil ltoc:t mouse:underline buttons:0 path:http://orgmode.org/org-info.js
 #+EXPORT_SELECT_TAGS: export
 #+EXPORT_EXCLUDE_TAGS: noexport
-#+LINK_UP:   
-#+LINK_HOME: 
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 #+XSLT: 
 
 #+STARTUP: oddeven

org-contrib/babel/languages/ob-doc-lilypond.org

@@ -6,6 +6,8 @@
 #+AUTHOR:     Martyn Jago
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 #+begin_html
   <div id="subtitle" style="float: center; text-align: center;">

org-contrib/babel/languages/ob-doc-mscgen.org

@@ -6,6 +6,8 @@
 #+AUTHOR:     Juan Pechiar
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 #+begin_html
   <div id="subtitle" style="float: center; text-align: center;">

org-contrib/babel/languages/ob-doc-octave-matlab.org

@@ -1,6 +1,8 @@
 #+TITLE:Org-babel-octave-matlab
 #+AUTHOR: Dan Davison
 #+EMAIL:  davison at stats dot ox dot ac dot uk
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 This file contains notes on using Matlab and Octave with Org-babel.
 

org-contrib/babel/languages/ob-doc-oz.org

@@ -6,6 +6,8 @@
 #+AUTHOR:     Torsten Anders, Eric Schulte
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
 
 #+begin_html
   <div id="subtitle" style="float: center; text-align: center;">

org-contrib/babel/languages/ob-doc-picolisp.org

@@ -0,0 +1,411 @@
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) noexport(n)
+#+TITLE:      PicoLisp Source Code Blocks in Org Mode
+#+AUTHOR:     Thorsten Jolitz
+#+EMAIL:      tj[at]data-driven[dot]de
+#+LANGUAGE:   en
+#+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ../languages.html
+#+LINK_HOME:  http://orgmode.org/worg/
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+#+name: banner
+#+begin_html
+  <div id="subtitle" style="float: center; text-align: center;">
+  <p>
+  Org Mode support for <a href="http://picolisp.com/5000/!wiki?home/">PicoLisp</a>
+  </p>
+  <p>
+  <a href="http://picolisp.com/5000/!wiki?home/">
+  <img src="http://picolisp.com/5000/wiki/logo.png"/>
+  </a>
+  </p>
+  </div>
+#+end_html
+
+* Template Checklist [12/12]                                       :noexport:
+  - [X] Revise #+TITLE:
+  - [X] Indicate #+AUTHOR:
+  - [X] Add #+EMAIL:
+  - [X] Revise banner source block [3/3]
+    - [X] Add link to a useful language web site
+    - [X] Replace "Language" with language name
+    - [X] Find a suitable graphic and use it to link to the language
+      web site
+  - [X] Write an [[Introduction]]
+  - [X] Describe [[Requirements%20and%20Setup][Requirements and Setup]]
+  - [X] Replace "Language" with language name in [[Org%20Mode%20Features%20for%20Language%20Source%20Code%20Blocks][Org Mode Features for Language Source Code Blocks]]
+  - [X] Describe [[Header%20Arguments][Header Arguments]]
+  - [X] Describe support for [[Sessions]]
+  - [X] Describe [[Result%20Types][Result Types]]
+  - [X] Describe [[Other]] differences from supported languages
+  - [X] Provide brief [[Examples%20of%20Use][Examples of Use]]
+* Introduction
+** Brief description of PicoLisp
+  PicoLisp is a minimal and pure Lisp dialect created by Alexander
+  Burger. First of all, PicoLisp is a virtual machine architecture,
+  and then a programming language. It is the result of a language
+  design study, trying to answer the question "What is a minimal but
+  useful architecture for a virtual machine?"
+  
+  However, PicoLisp is no academic exercise in language design. It has
+  been used in several commercial and research programming projects
+  since 1988. Its internal structures are simple enough, allowing an
+  experienced programmer always to fully understand what's going on
+  under the hood, and its language features, efficiency and
+  extensibility make it suitable for almost any practical programming
+  task. Some of the outstanding features of PicoLisp are:
+  
+- Integrated Database :: Database functionality is built into the core
+  of the language. PicoLisp is a database query and manipulation
+  language.
+
+  Database entities are first class objects. They are called
+  "external symbols", because they are automatically fetched from
+  database files when accessed, but otherwise behave like normal
+  symbols.
+
+  This fetching from external files is completely transparent, the
+  symbols "are just there", and there is no need (or even a
+  function) to read or write them explicitly. Pilog (a built-in
+  Prolog engine) is used as a query language.
+
+  It is possible with PicoLisp to build large multi-user databases,
+  distributed across many machines or in a cloud. Such a database
+  system can be optimally fine-tuned, because all its levels are
+  under the developer's control.
+
+- Equivalence of Code and Data :: This is actually a feature of Lisp in
+  general. However, PicoLisp really lives it. It makes it easy to write
+  things like the HTML, PostScript or TeX libraries, exploring a syntax
+  of nested function calls. This results in very succinct and precisely
+  expressed programs.
+
+  For a closer explanation, see the article [[http://picolisp.com/5000/!wiki?EquivalenceCodeData][The Equivalence of Code
+  and Data]]. 
+  
+- Expressiveness :: PicoLisp is a very expressive language. Programs are
+  often much shorter and concise than equivalent programs written in
+  other languages.
+
+  Examples of various programming tasks and their solutions can be
+  found at [[http://rosettacode.org/wiki/Category:PicoLisp][Rosettacode]].
+  
+- Efficiency :: PicoLisp uses (at least when compared to other Lisps)
+  very little memory, on disk as well as in memory (heap space).
+
+  For example, the installation size in the OpenWRT distribution is
+  only 575 kB (uncompressed), where the statically linked
+  interpreter with 296 kB takes the largest part. Yet, it includes
+  the full runtime system with interpreter, database, HTTP server,
+  XHTML and JavaScript application framework, watchdog, and the
+  debugger, PostScript and XML libraries.
+
+  PicoLisp has no compiler, everything starts up very quickly, and
+  code dynamically loaded at runtime (e.g. GUI pages) is
+  immediately ready. Yet, the interpreter is quite fast, usually
+  three times a fast as Python, for example.
+
+** Range of typical uses within Org Mode
+   At first sight, it might not be obvious why Org Mode users should
+   use anything else but Emacs Lisp when writing lisp code blocks. But
+   Picolisp offers at least two features that make it a valuable Org
+   Babel language: its object-oriented database, and its highly
+   efficient framework for interactive web-applications.
+
+* Requirements and Setup
+** Installation and configuration of PicoLisp software
+   PicoLisp can be downloaded from this [[http://software-lab.de/down.html][download page]]. There is a
+   32-bit version written in C, and a 64-bit version written in
+   assembler. Some GNU/Linux distributions ship with PicoLisp
+   packages, so you might be able to use your package manager for
+   installation. A pure Java version (Ersatz PicoLisp) and a minimal
+   version (Mini PicoLisp) are available too.
+
+   Detailed and comprehensive installation instructions can be found
+   in the [[http://software-lab.de/INSTALL][INSTALL]] file.
+   
+** Emacs configuration
+   The original author of PicoLisp, Alexander Burger, does all his
+   programming work using xterm and vi. PicoLisp is really living
+   the old Unix tradition of simplicity and minimalism.
+
+   However, there are no editor-wars going on in the PicoLisp
+   community. Several PicoLisp programmers are Emacs users and
+   contributed to Emacs to enable it as PicoLisp editor.
+   
+   After installing PicoLisp, you find the elisp files that constitute
+   the Emacs picolisp-mode in the directory /picolisp/lib/el/. There
+   is a picolisp.el and an inferior-picolisp.el as well as a paredit
+   patch.
+
+   There is another file called tsm.el. It makes PicoLisp's
+   transient symbols appear in a special way in the source code,
+   reminding the programmer that they look like Strings and are used
+   as Strings, but are not really Strings but just (transient)
+   Symbols.
+
+   The README file in the same directory gives the necesary
+   instructions for configuring the PicoLisp mode for Emacs. Since it
+   is not very long, I cite it here:
+
+   #+BEGIN_SRC emacs-lisp
+     ;; In order to get the picolisp-mode working correctly you have to
+     ;; add the following expressions to your .emacs and adapt them 
+     ;; according to your set-up: 
+     
+     (add-to-list 'load-path "<path-to>/picoLisp/lib/el")
+     (load "tsm.el") ;; Picolisp TransientSymbolsMarkup (*Tsm)
+     (autoload 'run-picolisp "inferior-picolisp")
+     (autoload 'picolisp-mode "picolisp" "Major mode for editing
+      Picolisp." t)
+     ;; pil is more modern than plmod
+     (setq picolisp-program-name "<path-to>/picoLisp/plmod") 
+     
+     ;; If you have also SLIME installed, it will suck all possible lisp
+     ;; extensions up (greedy bastard). 
+     ;; So in order to get the correct file-association for picolisp 
+     ;; files you'll have to also add this:
+     
+     (add-to-list 'auto-mode-alist '("\\.l$" . picolisp-mode))
+     
+     ;; If you want, you can add a few hooks for convenience:
+     
+     (add-hook 'picolisp-mode-hook
+        (lambda ()
+           (paredit-mode +1) ;; Loads paredit mode automatically
+           (tsm-mode) ;; Enables TSM
+           (define-key picolisp-mode-map (kbd "RET") 'newline-and-indent)
+           (define-key picolisp-mode-map (kbd "C-h") 'paredit-backward-delete) ) )
+     
+     
+     ;; By the way, don't forget to patch your paredit.el (v21) with the
+     ;;  patch provided to get a smoother editing. 
+   #+END_SRC
+
+
+** Org-mode configuration (org-babel-do-load-languages)
+   The ob-picolisp.el file is part of Emacs now. To activate PicoLisp
+   as an org-babel language, simply add (picolisp . t) to the
+   org-babel-do-load-languages function in your Emacs configuration
+   file, like shown below: 
+
+   #+BEGIN_SRC emacs-lisp
+     ;; activating picolisp as org babel language
+     (org-babel-do-load-languages
+      'org-babel-load-languages (quote ((emacs-lisp . t)
+                                         (picolisp . t)
+                                         (R . t)
+                                         (python . t))))
+   #+END_SRC
+
+* Org Mode Features for PicoLisp Source Code Blocks
+** Sessions
+*** Support or not
+    ob-picolisp supports external evaluation as well as session-based
+    evaluation of PicoLisp source blocks. 
+*** Typical use for sessions
+    Sessions preserve state, therefore the use of sessions in PicoLisp
+    just like in Emacs Lisp makes sense whenever the computations rely
+    on changing state. 
+** Header Arguments and Result Types
+*** Language-specific default values
+    Depending on the kind of table data you work with, it might be
+    convenient to set the following default header argument:
+
+    #+BEGIN_SRC emacs-lisp
+      ;; optionally declare default header arguments for this language
+      (defvar org-babel-default-header-args:picolisp
+        '((:colnames . "no"))
+        "Default arguments for evaluating a picolisp source block.")
+    #+END_SRC
+    
+*** Language-specific header arguments
+    There are no language specific header arguments for PicoLisp.     
+
+*** Combinations of header-args and result types
+   Many combinations of header arguments and result types are
+   supported by ob-picolisp. Like always in combinatorics, the number
+   of possible combinations increases rapidly when there are several
+   factors with several levels each that can be freely combined.
+
+   The following table shows combinations of header arguments and
+   result types that might make sense for a language like PicoLisp.
+   Many (but nor all) of them have been tried successfully with
+   ob-picolisp source blocks. 
+
+    #+tblname: header-args-combinations
+    | evaluation | collection | type              |
+    | (:session) | (:results) | (:results)        |
+    |------------+------------+-------------------|
+    | external   | value      | table (vector)    |
+    |            |            | scalar (verbatim) |
+    |            |            | file              |
+    |            |            | raw (org)         |
+    |            |            | html              |
+    |            |            | latex             |
+    |            |            | code              |
+    |            |            | pp                |
+    |            | output     | table (vector)    |
+    |            |            | scalar (verbatim) |
+    |            |            | file              |
+    |            |            | raw (org)         |
+    |            |            | html              |
+    |            |            | latex             |
+    |            |            | code              |
+    |            |            | pp                |
+    | session    | value      | table (vector)    |
+    |            |            | scalar (verbatim) |
+    |            |            | file              |
+    |            |            | raw (org)         |
+    |            |            | html              |
+    |            |            | latex             |
+    |            |            | code              |
+    |            |            | pp                |
+    |            | output     | table (vector)    |
+    |            |            | scalar (verbatim) |
+    |            |            | file              |
+    |            |            | raw (org)         |
+    |            |            | html              |
+    |            |            | latex             |
+    |            |            | code              |
+    |            |            | pp                |
+
+     
+    More special header arguments and their possible values are
+    summarized in the next table:
+   
+    #+tblname: other-header-args
+    
+    | header-arg |          | values  |          |         |
+    |------------+----------+---------+----------+---------|
+    | :results   | silent   | replace | append   | prepend |
+    | (handling) |          |         |          |         |
+    | :exports   | code     | results | both     | none    |
+    | :comments  | yes      | (no?)   |          |         |
+    | :noweb     | no       | yes     |          |         |
+    | :tangle    | yes      | no      | filename |         |
+    | :no-expand |          |         |          |         |
+    | :file      |          |         |          |         |
+    | :dir       |          |         |          |         |
+    | :cache     | no       | yes     |          |         |
+    | :var       | x=y      |         |          |         |
+    | :hlines    | no       | yes     |          |         |
+    | :colnames  | nil      | no      | yes      |         |
+    | :rownames  | no       | yes     |          |         |
+    | :shebang   | "string" |         |          |         |
+    | :eval      | never    | query   |          |         |
+
+
+** Other
+*** Differences from other supported languages
+    PicoLisp as an Org Babel language works quite similar like its
+close relatives Emacs Lisp and Scheme, for example.
+
+However, there is one characteristic that really sets it aparts from
+other supported languages: PicoLisp is not only a language, it _is_ a
+(object-oriented) database and a web-framework. Unlike other
+languages, that _have_ (external) frameworks and database drivers,
+these features are deeply integrated inside the PicoLisp application
+server framework. 
+
+As Alexander Burger describes it in [[http://software-lab.de/dbui.html][A Unifying
+Language for Database And User Interface Development]]:
+
+#+BEGIN_QUOTE
+: Databases and user interfaces are separate
+: worlds: Existing class libraries are concerned about
+: visual effects and event handling, but not about
+: application logic and database maintenance. It is the
+: programmer's responsibility to write glue code that
+: displays data in corresponding GUI fields, detects
+: modifications by the user, validates them, writes changes
+: back to the database, and does other housekeeping.
+:                  
+: [PicoLisp is] a language and programming
+: environment that closes [this] semantic gap, by unifying
+: database and user interface into a single application
+: server framework.
+#+END_QUOTE
+
+* Examples of Use
+** Hello World!
+The [[http://software-lab.de/doc/tut.html][PicoLisp Tutorial]] has two versions of the notorious "Hello World"
+function, one without arguments, the other with one argument:
+
+#+BEGIN_SRC picolisp :exports both :results output
+  # no arguments
+  (de hello-no-args ()
+     (prinl "Hello World"))
+  
+  (hello-no-args)
+#+END_SRC
+
+#+BEGIN_SRC picolisp :exports both :results output
+  # with one argument
+  (de hello-one-arg (X)
+     (prinl "Hello " X) )
+  
+  (hello-one-arg "Argument")
+#+END_SRC
+
+** Common uses
+   PicoLisp can be used, just like Emacs Lisp, as an efficient
+   scripting language inside of Org Mode documents. Due to its smart
+   and powerfull abstractions, much can be achieved in a few lines of
+   code.
+
+   From a PicoLisp programmer's point of view, the integration of the
+   language into Org Babel might be usefull for literate programming
+   (e.g. writing well documented PicoLisp libraries or PicoLisp
+   related papers) or for convenient database report building (making
+   use of Org Mode's multi-language environment and export
+   facilities).
+
+   From an Org Mode user's and/or Emacs Lisp programmer's point of
+   view, two use cases might be of special interest:
+
+   - use PicoLisp as a _real_ (object-oriented) database replacement
+     for things like bbdb and eieio, i.e. as a tool for
+     object-oriented lisp programming that can handle _big_ (even
+     replicated) databases, offers a powerfull prolog-based query
+     language (Pilog) and _speed_ (see [[http://picolisp.com/5000/!wiki?NeedForSpeed][The Need for Speed]]).
+   - use the PicoLisp application server framework to enable
+     interactive web-development with Org Mode, i.e. combine the
+     static html-export facilities of Org Mode with PicoLisp's ability
+     to produce html-forms that communicate directly with an
+     underlying PicoLisp database. 
+
+  These two use cases are still a bit theoretical, some investigation
+  and experimentation has to be done that hopefully lead to the
+  production of related tutorials on Worg in the future.
+   
+** Links to tutorials and other resources
+Although not all aspects of PicoLisp are documented and the (often
+surprinsingly short) source code must be used as ultimate reference in
+some cases, there are many interesting and well written documents
+available.
+
+The one-stop-shop for everything with regards to PicoLisp is the
+[[http://picolisp.com/5000/!wiki?home][PicoLisp Wiki]]. There is a [[mailto:picolisp@software-lab.de?subject%3DSubscribe][PicoLisp Mailing List]] too, as well as an IRC
+channel (#picolisp). 
+
+For programmers who want to learn more about PicoLisp, I would suggest
+to first read Paul Graham's essay [[http://paulgraham.com/hundred.html][The Hundred-Year Language]], to get
+the general idea what PicoLisp is all about. Then, a [[http://software-lab.de/radical.pdf][A Radical Approach
+to Application Development (PDF)]] and [[http://software-lab.de/dbui.html][A Unifying Language for Database
+And User Interface Development]] are the next logical steps to learn
+more about the philosophy behind PicoLisp.
+
+The [[http://software-lab.de/doc/ref.html][PicoLisp Reference]] and the [[http://software-lab.de/doc/tut.html][PicoLisp Tutorial]] are the main
+references when it comes to 'hands on' experience with the language.
+Henrik Sarvell's introduction [[http://www.prodevtips.com/2008/03/28/pico-lisp/]["At a First Glance"]] is a very helpfull
+beginners guide too. 
+
+The [[http://software-lab.de/doc/app.html][PicoLisp Application Development]] guide explains in great detail,
+how amazingly easy and efficient web-programming with PicoLisp can be.
+There is much more information available, just have a look at the
+PicoLisp wiki yourself.
+

org-contrib/babel/languages/ob-doc-template.org

@@ -7,7 +7,7 @@
 #+EMAIL:      you[at]email[dot]org
 #+LANGUAGE:   en
 #+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
-#+LINK_UP:    ../languages.php
+#+LINK_UP:    ../languages.html
 #+LINK_HOME:  http://orgmode.org/worg/
 #+EXPORT_EXCLUDE_TAGS: noexport
 
@@ -45,7 +45,6 @@
 * Introduction
   - Brief description of language.
   - Range of typical uses within Org Mode.
-  - Link to this Org Mode file.
 * Requirements and Setup
   - Installation and configuration of language software
   - Emacs configuration

org-contrib/gsoc2012/index.org

@@ -0,0 +1,110 @@
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) noexport(n)
+#+TITLE:      Google Summer of Code 2012
+#+AUTHOR:     Thorsten Jolitz
+#+EMAIL:      tj[at]data-driven[dot]de
+#+LANGUAGE:   en
+#+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+# #+LINK_UP:  http://orgmode.org/worg/org-faq.html
+#+LINK_HOME:  http://orgmode.org/worg/
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+
+#+name: banner
+#+begin_html
+  <div id="subtitle" style="float: center; text-align: center;">
+  <p>
+  Org Mode info-page for GNU's application to  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012">GSoC 2012</a>
+  </p>
+  <p>
+  <a
+  href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012"/>
+<img src="../../images/gsoc/DSCI0279_60pc.png"  alt="Beach, Books
+  and Beer"/>
+  </a>
+  </p>
+  </div>
+#+end_html
+
+
+* Google Summer of Code (GSoC) 2012
+** How Google describes it
+Here is how Google describes the goals of the GSoC program:
+
+#+BEGIN_QUOTE
+"Google Summer of Code is a program that offers student developers
+stipends to write code for various open source projects (see the [[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][faq]]
+for more information).
+
+Google Summer of Code has several goals:
+
+- Create and release open source code for the benefit of all
+- Inspire young developers to begin participating in open source development
+- Help open source projects identify and bring in new developers and committers
+- Provide students the opportunity to do work related to their
+  academic pursuits (think "flip bits, not burgers")
+- Give students more exposure to real-world software development
+  scenarios (e.g., distributed development, software licensing
+  questions, mailing-list etiquette)"
+#+END_QUOTE
+
+(quoted from the official [[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][GSoC 2012]] home page)
+
+** Org Mode participates in GSoC 2012
+This year, the Org Mode community will apply for the first time
+as mentoring organisation for Google's Summer of Code program.
+
+Students will love the opportunity to contribute to a software they
+might use on a daily basis anyway. Org Mode is not only one out of
+many interesting open-source projects out there, it is a software tool
+custom-made for the needs of students (and scientists in general).
+
+They can use Org Mode for organising their life, their studies and
+their finances. They can write their research papers with it as well
+as publish their website. Not to mention their spreadsheet
+calculations and their (literate) programming work in some 30 Org
+Babel languages. And they can do all this with the unsurpassed
+efficiency only offered by the combination of Emacs & Org Mode. 
+
+Working on an Org Mode project this summer not only will make the
+students better (Emacs) Lisp programmers, it will make them better
+students too, since skilled Elisp programmers are Emacs power users by
+definition and can make the most out of their exceptionally powerfull
+software tool. 
+
+The students will have the exciting opportunity to join one of the
+most dynamic open-source projects today with a big, active, skilled
+and very helpfull community. Since the Org Mode project is in such a
+dynamic momentum, there are plenty of usefull ideas for student
+projects around. In fact, some long desired features for Org Mode
+might finally be realized through students projects during the
+GSoC 2012.
+
+** Mentors, students and ideas
+Org Mode contributers that are not students anymore, but would like to
+see some of their ideas with regards to Org Mode come true, are
+invited to post these ideas on the [[file:orgmode-gsoc2012-ideas.org][ideas page]] and apply as mentors.
+Students are encouraged to either apply for one of the proposed
+projects on the ideas page or submit their own ideas and ask one of
+the experienced Org Mode contributors if he would like to mentor their
+project.
+
+** Info pages
+Although all related information can be found on the [[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][GSoC 2012]] home
+page, we prepared an [[file:orgmode-gsoc2012-admin.org][admin page]], a [[file:orgmode-gsoc2012-mentor.org][mentor page]] and a [[file:orgmode-gsoc2012-student.org][student page]] that
+only gives the information relevant for the respective group. Remember
+that these pages only serve for a quick overview. The complete,
+up-to-date and authorized information can be found on the original
+[[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][GSoC 2012]] home page. 
+
+The most important page is the [[file:orgmode-gsoc2012-ideas.org][ideas page]]. Since the application
+process is a two step process, first the organisation (Org), then the
+students, all student projects depend on the successfull application
+of the mentoring organisation. 
+
+Therefore we should try to build a nice ideas page, grouping the
+proposals by topics, with a description for each idea. It
+would be nice to associate each idea with a mentor too. 
+

org-contrib/gsoc2012/orgmode-gsoc2012-admin.org

@@ -0,0 +1,209 @@
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) noexport(n)
+#+TITLE:      Google Summer of Code 2012
+#+AUTHOR:     Thorsten Jolitz
+#+EMAIL:      tj[at]data-driven[dot]de
+#+LANGUAGE:   en
+#+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ./index.html
+#+LINK_HOME:  http://orgmode.org/worg/
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+
+#+name: banner
+#+begin_html
+  <div id="subtitle" style="float: center; text-align: center;">
+  <p>
+  Org Mode info-page for GNU's application to  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012">GSoC 2012</a>
+  </p>
+  <p>
+  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012"/>
+<img src="../../images/gsoc/DSCI0279_60pc.png"  alt="Beach, Books
+  and Beer"/>
+  </a>
+  </p>
+  </div>
+#+end_html
+
+
+
+* Org Mode GSoC 2012 Admin Page
+Please note the following disclaimer before relying on the information
+given below:
+
+#+BEGIN_QUOTE
+"The following information is quoted verbatim from Google's excellent [[http://www.google-melange.com/document/show/gsoc_program/google/gsoc2012/faqs][faq]]
+page. It summarizes all the information relevant for GSoC 2012
+*admins*. "We" in the following text stands for "Google",
+not for "Org Mode" or "GNU". 
+
+This page only serves as a quick overview for one particular group of
+GSoC participants, the admins. It might be incomplete, out of date
+or even erroneous.
+
+If you want the complete, up-to date and authorized information,
+please visit [[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][Google's GSoC 2012]] page."
+#+END_QUOTE
+
+
+We'll begin accepting applications from open source mentoring
+organizations on February 27, 2012; we'll stop accepting organization
+applications on March 9th at 23:00 UTC.
+
+
+** What is a mentoring organization?
+
+A group running an active free/open source software project, e.g. the
+Python Software Foundation. The project does not need to be a legally
+incorporated entity. If you're looking for a broader picture, you can
+find a list of all mentoring organizations who have participated in
+the past on the Google Summer of Code 2005, 2006, 2007, 2008, 2009,
+2010, and 2011 pages. Mentoring organizations must produce and release
+software under an Open Source Initiative approved license in order to
+participate in the program. Mentors for their organizations must at
+least be committers for the corresponding project and their
+participation in Google Summer of Code on the organization’s behalf
+must be approved by the organization administrator via Melange.
+
+** What is the role of a mentoring organization?
+
+Each mentoring organization is expected to provide:
+
+ + A pool of project ideas for students to choose from, publicly
+   published by the mentoring organization as an Ideas list
+ 
+ + An organization administrator to act as the project's main point of
+   contact for Google
+ 
+ + A person or group responsible for review and ranking of student
+   applications, both those proposals which tie into the org's Ideas
+   list and "blue-sky" proposals
+  
+ + A person or group of people responsible for monitoring the progress
+   of each accepted student and to mentor her/him as the project
+   progresses
+
+ + A person or group responsible for taking over for a student's
+   assigned mentor in the event they are unable to continue mentoring,
+   e.g. take a vacation, have a family emergency
+ 
+ + A written evaluation of each student participant, including how
+   s/he worked with the group, whether you would want to work with
+   them again
+
+
+In addition to these responsibilities, a mentoring organization should
+actively encourage each student developer to participate in the
+project's community in whichever way makes the most sense for the
+project, be it development mailing lists, idling in the project's IRC
+channel, participating in the project's forum, etc. A truly successful
+mentoring organization will work diligently to ensure that as many of
+their students as possible remain active project participants long
+after the conclusion of the program.
+
+** What is the role of an organization administrator?
+
+An organization administrator oversees the overall progress of a
+mentoring organization and its students throughout the program.
+Organization administrators will have different responsibilities
+depending on the organization, but at the very least they will need
+to:
+
+1. Submit the organization's program application to Google
+2. Act as the main point of contact between Google and the organization
+3. Respond to any inquiries from Google within 48 hours
+4. Assign a back up mentor should a mentor be unable to work with a student
+5. Ensure all program evaluations are completed on time on or before the deadlines
+
+For some projects, the organization administrator also acted as an
+arbiter when disputes arose between students and mentors, but each
+project should individually decide how such situations should be
+handled.
+
+** Can a mentoring organization have more than one administrator?
+
+Yes, in fact it is required. It's good to have a back-up administrator
+identified who can cover for your administrator should s/he go out of
+town, etc. If your back-up administrator becomes the primary
+administrator, make sure to notify Google's program administrators.
+
+** What kind of mentoring organizations should apply?
+
+As you can see from the lists of our mentoring organizations for 2005,
+2006, 2007, 2008, 2009, 2010, and 2011 many different types of open
+source projects participate in Google Summer of Code. As long as your
+project can provide mentors and is releasing code under an Open Source
+Initiative approved license, you are welcome and encouraged to apply.
+Unfortunately, there are far more great open source projects than we
+can work with, so if your project is highly niche or has very few
+users, chances are that your application will not be accepted.
+
+** When will accepted mentoring organizations be announced?
+
+We will announce the list of accepted mentoring organizations on the
+Google Summer of Code 2012 homepage on March 16, 2012.
+
+** Are mentoring organizations required to use the code produced?
+
+No. While we hope that all the code that comes out of this program
+will find a happy home, we're not requiring organizations to use the
+students' code.
+
+** What are the eligibility requirements for mentoring organizations?
+
+Mentor organizations must be organizations or individuals running an
+active and viable open source or free software project whose
+applications are approved by Google's Open Source Programs Office.
+Organizations based in Iran, Syria, Cuba, Sudan, North Korea and
+Mynamar (Burma), with whom we are prohibited by U.S. law from engaging
+in commerce, are ineligible to participate.
+
+** Who owns the code produced by student developers?
+
+Each student (or her/his mentoring organization) must license all
+student Google Summer of Code code under an Open Source Initiative
+approved license palatable to the mentoring organization. Some
+organizations will require students to assign copyright to them, but
+many will allow them to retain copyright. If Google is a student's
+sponsoring organization, then the student keeps copyright to her/his
+code.
+
+** What licenses do I have choose from?
+
+That depends on your mentoring organization. All code created by
+student participants must be released under an Open Source Initiative
+approved license. It's also extremely likely that your mentoring
+organization will have a preferred license(s) and that you will need
+to release your code under the license(s) chosen by that organization.
+
+** Isn't it unusual for open source developers to be paid?
+
+Not really. Many of our mentors get paid to work on open source. Some
+run their own consultancies, others tinker for some cash on the side,
+others work for large companies. That said, we do know it is tricky to
+introduce cash into the mix of Free and Open Source, but that is why
+we're working with external organizations with years of collective
+experience in this kind of thing.
+
+
+** What tax related documentation is required from mentoring organizations?
+
+
+We will need the following tax related documentation from mentoring
+organizations or umbrella organizations:
+
+   + For organizations based in the United States, we will need a
+     completed IRS form W9.
+   
+   + For organizations based outside the United States, we will need a
+     completed IRS form W8-BEN.
+
+
+All organizations are paid via purchase order from Google, which will
+require registering as a vendor in our payments system. Detailed
+instructions for registering as a vendor and invoicing Google for
+payment will be sent to the private mentors' mailing list. We will
+need to have all required documentation on file before issuing payment
+to a particular mentoring organization.

org-contrib/gsoc2012/orgmode-gsoc2012-ideas.org

@@ -0,0 +1,217 @@
+#+OPTIONS:    H:4 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) noexport(n)
+#+TITLE:      Google Summer of Code 2012
+#+AUTHOR:     Thorsten Jolitz
+#+EMAIL:      tj[at]data-driven[dot]de
+#+LANGUAGE:   en
+#+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ./index.html
+#+LINK_HOME:  http://orgmode.org/worg/
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+
+#+name: banner
+#+begin_html
+  <div id="subtitle" style="float: center; text-align: center;">
+  <p>
+  Org Mode ideas for GNU's application to  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012">GSoC 2012</a>
+  </p>
+  <p>
+  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012"/>
+<img src="../../images/gsoc/DSCI0279_60pc.png"  alt="Beach, Books
+  and Beer"/>
+  </a>
+  </p>
+  </div>
+#+end_html
+
+
+* Org Mode GSoC 2012 Ideas Page
+** Real webprogramming with Org Mode and PicoLisp
+*Project Description:*
+[[http://picolisp.com/5000/!wiki?home][PicoLisp]] is one out of many [[http://orgmode.org/worg/org-contrib/babel/languages.html][Org Babel languages]], but may be special in
+the sense that it does not only contribute to the static
+webpublishing capacities, but may introduce dynamic webprogramming on
+top of a real database into Org Mode. 
+
+Real interactive webprogramming frequently involves a (SQL) database
+like MySQL, a programming language like PHP or Python to build a MVC
+(Model-View-Controller) application on top of the database, a web
+framework for that programming language to make the programmers life
+easier (e.g. Django for Python), and a persistence layer that abstract
+away the conceptual mismatch between the SQL database and the (mostly)
+object-oriented application. Sometimes, a WYSIWYG html editor like MS
+Frontpage is invovled too, when webdesigners design the UI of the
+application. 
+
+Such an application needs user input (via <form> or <input> elements
+in the html pages) and needs to adapt dynamically to the users actions
+and queries by updating either the whole page or only parts of it
+(Javascript). For each user, a session is needed to keep track of the
+state of the application during his/her visit. 
+
+This kind of dynamic webprogramming can't be done with Org Mode.
+Typical webpages made with Org Mode are static in nature, even if they
+update their content frequently with some cron jobs on the server.
+There is no interaction with the user. 
+
+Considering the web stack for dynamic web apps described
+above, Org Mode really functions as a kind of 'Frontpage on steroids'
+for highly skilled academics. The project idea is to let PicoLisp
+replace all the other elements of the webstack and combine Org Mode
+and PicoLisp into an entirely Lisp-based framework for dynamic web
+programming. 
+
+In the PicoLisp application framework, UI and database are unified.
+Database objects are first class members of the language, and the UI
+elements act directly on this object-oriented lisp database (that is
+fast and scalable). No external SQL storage is needed, no persistence
+layer between the relational world of the DB and the object-oriented
+world of the application, and no glue code (controller) that connects
+the view to the model. 
+
+By merging PicoLisp's framework for rapid web-application development
+with Org Modes framework for rapid (web-) content production via Org
+Babel, new kinds of websites produced with Org Mode should become
+possible.
+
+*Difficulty:*
+Medium
+
+*Requirements:*
+Elisp, PicoLisp
+
+*Recommended:* 
+Knowledge about the inner workings of Org-babel and the
+PicoLisp application programming framework, some experience with Git.
+
+*Mentors:*
+Bastien Guerry, Eric Schulte
+
+** Git merge tool for Org files
+*Project Description:*
+This project idea is about writing a git merge driver for Org mode
+files, in the way [[http://git.savannah.gnu.org/gitweb/?p%3Dgnulib.git%3Ba%3Dblob%3Bf%3Dlib/git-merge-changelog.c][git-merge-changelog]] does this for GNU style
+ChangeLog files?
+
+One of the obstacle for using Org-mode for collaborative programs is
+that many operations add or remove text from the beginning or end of a
+file, or which add or remove a subnode from an outline tree. These are
+operations that confuse the git merger, in particular if two people
+have added something to a file, or removed/added sequential sibling
+nodes.
+
+I believe that this could be solved with a dedicated merge driver that
+understands the integrity of an outline (sub)tree, and that knows that
+the sequence of two new subtrees added by different people does not
+matter.
+
+The idea for this is actually (I believe) from Brian Gough who asked
+me about it at FOSDEM. I have now also run into this problem and would
+really find it great if such a merge driver could be written. 
+
+*Difficulty:*
+Hard
+
+*Requirements:*
+Git, Elisp, C
+
+*Recommended:* 
+Good understanding of Git and the structure of Org-mode files. 
+
+*Mentors:*
+Carsten Dominik
+
+** Implement an Elisp backend for Ragel 
+*Project Description:*
+Ragel http://www.complang.org/ragel/ is a tool
+that integrates regular expressions and state machines under one
+umbrella. It has backends currently for C, C++, Objective-C, D, Java
+and Ruby. Programming an Elisp backend would be a manageable task for
+a GSoC project.
+
+After that org-mode code might become half as long and twice as
+fast - at least those sections that are heavily regex oriented.
+
+*Difficulty:*
+Medium
+
+*Requirements:*
+Elisp, RegExp
+
+*Recommended:* 
+Familiarity with Org-mode, regular expressions and state machines.
+
+*Mentors:*
+Bastien Guerry, Rustom Mody
+
+
+** "Notebook" like console interface on top of Org Mode/ Babel
+*Project Description:*
+Implementing a multi-programming-language "notebook" like console
+interface build on top of Org-mode and Babel (with both Emacs and
+HTML interfaces).
+
+*Difficulty:*
+Medium
+
+*Requirements:*
+Elisp, HTML
+
+*Recommended:* 
+Familiarity with Org-mode and Babel
+
+*Mentors:*
+Eric Schulte
+
+** Asynchronous code block execution for Org Babel
+*Project Description:*
+Adding support for asynchronous code block execution.
+
+*Difficulty:*
+Medium
+
+*Requirements:*
+Elisp, C
+
+*Recommended:* 
+Good understanding of Org Babel and the GNU/Linux process model.
+
+*Mentors:*
+Eric Schulte
+
+** Piping results between Babel code blocks
+*Project Description:*
+Adding support for piping results between code blocks allowing many
+blocks to run concurrently (probably best combined with asynchronous
+execution).
+
+*Difficulty:*
+Medium
+
+*Requirements:*
+Elisp, C
+
+*Recommended:* 
+Good understanding of Org Babel and the GNU/Linux process model.
+
+*Mentors:*
+Eric Schulte
+
+** Handling Babel code block output written to STDERR
+*Project Description:*
+Adding support for handling output written to STDERR.
+
+*Difficulty:*
+Medium
+
+*Requirements:*
+Elisp
+
+*Recommended:* 
+Familiarity with Org Babel and GNU/Linux.
+
+*Mentors:*
+Eric Schulte

org-contrib/gsoc2012/orgmode-gsoc2012-mentor.org

@@ -0,0 +1,131 @@
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) noexport(n)
+#+TITLE:      Google Summer of Code 2012
+#+AUTHOR:     Thorsten Jolitz
+#+EMAIL:      tj[at]data-driven[dot]de
+#+LANGUAGE:   en
+#+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ./index.html
+#+LINK_HOME:  http://orgmode.org/worg/
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+
+#+name: banner
+#+begin_html
+  <div id="subtitle" style="float: center; text-align: center;">
+  <p>
+  Org Mode info-page for GNU's application to  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012">GSoC 2012</a>
+  </p>
+  <p>
+  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012"/>
+<img src="../../images/gsoc/DSCI0279_60pc.png"  alt="Beach, Books
+  and Beer"/>
+  </a>
+  </p>
+  </div>
+#+end_html
+
+
+* Org Mode GSoC 2012 Mentor Page
+Please note the following disclaimer before relying on the information
+given below:
+
+#+BEGIN_QUOTE
+"The following information is quoted verbatim from Google's excellent [[http://www.google-melange.com/document/show/gsoc_program/google/gsoc2012/faqs][faq]]
+page. It summarizes all the information relevant for GSoC 2012
+*mentors*. "We" in the following text stands for "Google",
+not for "Org Mode" or "GNU". 
+
+This page only serves as a quick overview for one particular group of
+GSoC participants, the mentors. It might be incomplete, out of date
+or even erroneous.
+
+If you want the complete, up-to date and authorized information,
+please visit [[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][Google's GSoC 2012]] page." 
+#+END_QUOTE
+
+** How do evaluations work?
+
+Google will pre-publish the evaluation questions for both students and
+mentors. Mentors will fill out mid-term and final evaluations for
+their students via the Google Summer of Code 2012 site. These
+evaluations will be visible in the system to the mentor and the
+mentoring organization's administrator(s). Students will fill out a
+mid-term and final evaluation of their mentors online as well, and
+their evaluations will only be visible in the system to the mentoring
+organization's administrator(s). Program administrators from Google
+will have access to all evaluation data.
+
+Any student who does not submit an evaluation by the evaluation
+deadline will fail that evaluation, regardless of the grade the mentor
+gives the student. If a student submits his or her evaluation on time
+but the mentor does not, then the student is in an “undecided” state
+until the program administrators can speak to the mentor and determine
+the student’s grade.
+
+Students who fail the mid-term are immediately removed from the
+program: it’s not possible to fail the mid-term, stay in the program,
+and then have a final evaluation.
+
+In almost all cases, students will never see their mentor's evaluation
+of their progress, nor will a mentor see a student's evaluation of
+her/his mentorship. However, in the case where the mentoring
+organization's administrator and a student's mentor are one and the
+same, the student's evaluation will be shared with the mentor. If you
+are a student in a situation where your mentor is also your
+organization’s administrator and you would like to discuss an issue
+with the program, please contact the Google Summer of Code program
+administrators. Organization administrators are expected to review
+mid-term and final evaluations and to provide course corrections where
+necessary. In some cases, Google's program administrators may need to
+share the results of evaluations with the student and mentor, such as
+to arbitrate when payment should not be made. Should this need arise,
+all parties will be notified in advance.
+
+In the unlikely event that a mentor and organization administrator do
+not agree on a student’s grade for any evaluation, the decision of the
+organization administrator is the final one.
+
+In the also unlikely event that a student does not agree with a
+mentoring organization’s evaluation decision at either the midterm or
+the final, the student may choose to submit his/her entire project
+plan, timeline and code sample to Google’s program administrators.
+Google will choose an independent engineer to review the code and
+arbitrate the decision. The decision of Google’s independent engineer
+is final.
+
+Finally, any mentor who misses a deadline for an evaluation of his/her
+student without notifying the program administrators beforehand will
+not be allowed to attend the Google Summer of Code mentor summit.
+Timely evaluations of Google Summer of Code students are crucial to
+us.
+
+** What are the eligibility requirements for mentors?
+
+Google does not have specific eligibility requirements for mentors, as
+we know our mentoring organizations will be best able to determine the
+selection criteria for their mentors.
+
+** I would like to participate in Google Summer of Code as both mentor and a student. Is this possible?
+
+We've given this question a lot of thought, and we've decided it is
+best not to allow participants to act as a mentor to another Google
+Summer of Code student while they are working on their own Google
+Summer of Code student project. We want to make sure that each project
+and student receives sufficient attention, and we're concerned that
+this split in focus could create a bad experience for those involved.
+Please choose whether participation as a mentor or a student is more
+appealing to you and plan to apply accordingly.
+
+** How much time is required to participate as a mentor in Google Summer of Code?
+
+While the answer to this question will vary widely depending on the
+number of students a mentor works with, the difficulty of the
+proposals, and the skill level of the students, most mentors have let
+us know that they underestimated the amount of time they would need to
+invest in Google Summer of Code. Five hours per student per week is a
+reasonable estimate.
+
+

org-contrib/gsoc2012/orgmode-gsoc2012-student.org

@@ -0,0 +1,330 @@
+#+OPTIONS:    H:3 num:nil toc:2 \n:nil @:t ::t |:t ^:{} -:t f:t *:t TeX:t LaTeX:t skip:nil d:(HIDE) tags:not-in-toc
+#+STARTUP:    align fold nodlcheck hidestars oddeven lognotestate hideblocks
+#+SEQ_TODO:   TODO(t) INPROGRESS(i) WAITING(w@) | DONE(d) CANCELED(c@)
+#+TAGS:       Write(w) Update(u) Fix(f) Check(c) noexport(n)
+#+TITLE:      Google Summer of Code 2012
+#+AUTHOR:     Thorsten Jolitz
+#+EMAIL:      tj[at]data-driven[dot]de
+#+LANGUAGE:   en
+#+STYLE:      <style type="text/css">#outline-container-introduction{ clear:both; }</style>
+#+LINK_UP:    ./index.html
+#+LINK_HOME:  http://orgmode.org/worg/
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+
+#+name: banner
+#+begin_html
+  <div id="subtitle" style="float: center; text-align: center;">
+  <p>
+  Org Mode info-page for GNU's application to  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012">GSoC 2012</a>
+  </p>
+  <p>
+  <a href="http://www.google-melange.com/gsoc/homepage/google/gsoc2012"/>
+<img src="../../images/gsoc/DSCI0279_60pc.png"  alt="Beach, Books
+  and Beer"/>
+  </a>
+  </p>
+  </div>
+#+end_html
+
+* Org Mode GSoC 2012 Student Page
+** Insights, Tips and Tricks from a former GSoC student
+[Thanks a lot to 'LRN' for sharing his experiences and insights with
+regards to GSoC!]
+
+*** Preparing the application 
+Here's what i have to say on the topic (it's mostly freeform, so i
+decided not to send it as a text file; if you do need a text-file
+version, ask - i'll provide it):
+
+Your chances to get accepted and complete GSoC successfully will
+increase, if you're very good at software development. "Very good at"
+usually means that you're top of your programming class, and you
+probably dabbled in software development before becoming a student. If
+you develop software on a regular basis, your skill will (usually)
+raise over time, and your chances to complete GSoC will raise along
+with it (that is, second-year students have more chances than
+first-year students).
+If you're a year away from your graduation and you've been the top
+student in your programming class, and you're matching all other
+requirements of a project, then (barring any unfortunate turns of
+events) the probability of you being accepted and passing GSoC
+successfully is nearly 100% (unless you're terminally lazy).
+That said, if you aren't as skilled, but your experience with software
+development has told you that you might have the right aptitude, then
+you have a chance, never doubt that!
+
+Obviously, look at the projects/organizations that use the programming
+languages you know. You might not have a lot of experience using that
+particular language; it's usually enough to just be familiar with it
+(i.e. complete a course in C++ without writing any real C++ programs
+other than those required to pass the course exams).
+If you are not familiar with the programming language required to
+apply for a project, but believe that you meet all other criteria (see
+below), consider your learning ability, and try to read a tutorial or
+a book that teaches the required programming language. If you know 2
+or 3 different languages and know the right programming paradigm,
+learning a new programming language is not very difficult.
+If you are not an experienced programmer, and need to learn a language
+for a project, then look for a project that requires the use of an
+easy-to-learn language (Python, Ruby, etc). That will improve your
+chances.
+If learning is required, then do talk with the developers. Some
+organizations have welcoming community and will gladly help you to
+learn; others will not, and you will be left to your own devices.
+
+Discuss an application with the developers. At length. Use IRC or a
+mailing list - whatever is best for a given organization (some
+organizations favor IRC, other - mailing lists). They might suggest
+some ideas or variations not present in their ideas list.
+
+You can also propose your own projects! If you've been dying to
+implement a new feature in your favorite software package - here's
+your chance! That is, if you find someone who will agree to be your
+mentor for that project.
+
+Fixing several long-sanding bugs might be considered important enough
+to constitute a project. In fact, many pieces of software need
+bugfixing more than new features, so don't be afraid to suggest
+yourself for a role of Bugfixing Guru (that is, if you're sure of your
+bugfixing abilities in the context of that particular organization).
+
+Some (but not all) projects require not just programming skills, but
+also some scientific or engineering knowledge (such as signal
+processing, gene sequencing, law, artificial intelligence, and all
+kinds of math). If you have the knowledge required for a project, and
+are able to program at all (but not on the right language), then
+that's probably better than knowing the required programming language,
+but not having enough knowledge in the right field. But, again, not
+all project require that kind of special knowledge.
+
+Once you've chosen a promising project (or came up with an idea of
+your own, and the developers from the organization you're aiming to
+apply to think it to be a good idea, and you've found a mentor for
+it), try to download and compile the source code for the software
+you'll be working upon. If you need help compiling it - look for
+tutorials/HOWTOs. Also ask the developers - they might have something
+to say regarding your particular build environment and/or platform.
+If you succeed - mention that in your application. It will score you
+some additional points with the developers.
+
+Once you've got things compiling, try to write something. If a [small]
+subset or part of your project (one small feature, handling only some
+of the simplest cases, and full of dirty hacks) can be completed
+quickly enough (a couple of days) - try to do that. Otherwise, come up
+with some schemes, or make a verbal descriptions of the changes you're
+going to make, pointing out the places in the application's code that
+will require changes, and how your code will interact with it.
+If the project requires some kind of protocol or data storage - come
+up with a protocol description or a storage format specification. If
+the software you're going to develop is complex enough - make a
+diagram or a flowchart that shows the components (existing and
+yet-to-be-developed ones), and how they interact.
+All of that will show the developers that you understand their code
+and your task.
+
+If the organization you're applying to has a wiki and allows you to
+use it - do use it to publish some of the information for your
+application. While Google will keep your application in Melange for
+historical purposes, and it won't be lost afterwards, adding info to
+organization's wiki page is already a small contribution and improves
+your image.
+
+Language skills are important. While this might not apply to all
+communities, you'll usually get best results by participating in any
+discussions (in chats and mailing lists) among the developers, if you
+have something meaningful to say (but avoid "bikeshedding"). And you
+should try your best to participate in any discussions related to your
+project. With anyone, not just your mentor. If you're accepted, keep
+your discussions public. Ask for advice, or for other developers'
+opinion on things you do. Your mentor has some authority over you and
+your project, but other developers might be able to help you better
+(especially if your mentor is not available as often as you'd like
+him/her to be), and their insights are valuable.
+All that means knowing the right foreign language. If the developers
+only speak English, and you don't, your chances to be accepted will be
+lower (and if you're accepted, it might be more difficult to complete
+the project). If one of the developers speaks the same language as you
+do (happens in some large international organizations) - you might
+pass, but again, this will hamper your ability to participate in
+public discussions, which might reflect badly on your project.
+
+Your ability to learn is important.
+Good learning skills will allow you to quickly cover your lack of
+knowledge or skill before and during the application period, and they
+will help you complete the project once you're accepted. All software
+developers learn, and you, as a student, will learn even more. Even if
+you're an accomplished programmer, you still stand to learn a thing or
+two.
+
+If all of the above made you think that students who are well-prepared
+and well-educated in programming, social interactions and sciences
+have better chances of being accepted - you're absolutely right.
+Luckily, such students are relatively rare. Don't be discouraged, even
+if you're lacking in something - you'll learn as you go.
+
+If you don't know English (or whatever language the developers are
+using among themselves; but it's usually English) as good as you'd
+like - take some time to write and proof-read your e-mails to the
+mailing list, and try to participate in chats as best as you can. You
+might notice that your command of English improves over time. Hey, in
+many educational programs you have to pay to learn something. In GSoC
+Google is paying YOU to learn! How cool is that?!
+
+All things considered, it's better to do 2-3 good and well-researched
+applications, than to apply for 10 projects simultaneously. Don't
+spread yourself too thin.
+
+Don't lie. Be objective.
+
+*** Once you're accepted:
+
+If you haven't done everything described above (code compiling, tools
+familiarity, learning to participate in community discussions,
+project-related research) - do that. There will be a stretch of time
+called "Community Bonding Period" (about a month), it's purpose is for
+you to get familiar with the code base, tools, documentation,
+developers, etc (yes, that's right: while you're supposed to do some
+of those things AFTER being accepted, doing them BEFORE being accepted
+improves your chances to be accepted; sad, but true).
+
+Google will require a copy of all your contributions at the end of the
+program. Just a formality, but make it easy for yourself, and set up
+some kind of version control system (or use the one the organization
+of your choosing uses). Later you'll be able to dump all your changes
+as patches, pack them and send that tarball to Google.
+
+If you completed a 3-month project in 3 days, it means one of the
+following:
+
+  - You're a genius. The developers will find more work for your agile
+    mind.
+  - Your project is too easy. The developers will find more work to
+    fill your spare time. 
+
+But that is a rare occurrence. Usually you'll be running out of time
+instead. But it's OK to review your project during mid-term evaluation
+and set new (realistic) goals, if the original ones can not be
+achieved in time, and there are objective reasons for that. But it's
+better to set realistic goals from the start, rather than change them
+as you go.
+Some projects allow for several stages of completeness. For example, a
+project might include a major feature and a couple of minor features;
+if you can't finish everything in time - concentrate on the major
+feature, you might still pass the evaluation (obviously all that is to
+be discussed with your mentor).
+
+Don't take long breaks. The longer you stay out of the development,
+the harder it becomes to dive back (although it depends on the nature
+of the project and on your talents and personality; sometimes a
+project is so interesting, that you can't wait to code some more!).
+
+If you're not coding for your project - think about your project. Thinking
+helps too (sadly, it does not help you to pass the evaluation; a lot
+of well-written and working code does).
+
+ 
+** Google's Info for Students
+Please note the following disclaimer before relying on the information
+given below:
+
+#+BEGIN_QUOTE
+"The following information is quoted verbatim from Google's excellent [[http://www.google-melange.com/document/show/gsoc_program/google/gsoc2012/faqs][faq]]
+page. It summarizes all the information relevant for GSoC 2012
+*students*. "We" in the following text stands for "Google",
+not for "Org Mode" or "GNU". 
+
+This page only serves as a quick overview for one particular group of
+GSoC participants, the students. It might be incomplete, out of date
+or even erroneous.
+
+If you want the complete, up-to date and authorized information,
+please visit [[http://www.google-melange.com/gsoc/homepage/google/gsoc2012][Google's GSoC 2012]] page." 
+#+END_QUOTE
+
+The student application period begins March 26, 2012 and ends April
+6th at 19:00 UTC. 
+
+*** How does a student apply?
+
+Students can submit their applications via the Google Summer of Code
+2012 site from March 27 - April 9, 2012. We hear almost universally
+from our mentoring organizations that the best applications they
+receive are from students who took the time to interact and discuss
+their ideas before submitting an application, so make sure to check
+out each organization's Ideas list to get to know a particular open
+source organization better. In addition to an application, students
+will be required to sign a Student Participation Agreement.
+
+*** What should a student application look like?
+
+Your application should include the following: your project proposal,
+why you'd like to execute on this particular project, and the reason
+you're the best individual to do so. Your proposal should also include
+details of your academic, industry, and/or open source development
+experience, and other details as you see fit. An explanation of your
+development methodology is a good idea, as well. It is always helpful
+to include contact information as well, as it will not be
+automatically shared with your would-be mentors as part of the
+application process. If the organization you want to work with has a
+specific application template they would like you to use, it will be
+made available to you to fill in when submitting your proposal via the
+Google Summer of Code web app. [note: the PicoLisp community has not
+specific application template]
+
+*** Can a student submit more than one application?
+
+Yes, each student may submit up to twenty applications. However, only
+one application will be accepted. We've heard from our mentoring
+organizations that quality is better than quantity.
+
+*** Can students already working on an open source project continue to work on it as part of Google Summer of Code?
+
+Yes, as long as they meet all other requirements for program
+eligibility. Students should be sure to note their previous
+relationship with the project in their applications. New work will
+need to be done for the project as part of participation in Google
+Summer of Code.
+
+*** Should students begin working on their applications before Google begins accepting program applications?
+
+That's up to you. Keep in mind, though, that our mentoring
+organizations will be publishing a list of proposed project ideas, so
+you may find that you'll want to revamp your application later, or
+create an entirely new one to address one of those ideas.
+
+*** Can a student work on more than one project?
+
+No, each participant may only work on one project and is only eligible
+for one stipend.
+
+*** Can a group apply for and work on a single proposal?
+
+No, only an individual may work on a given project.
+
+*** What happens if two students are accepted to work on the same project, e.g. from an organization's Ideas list?
+
+That's fine, a little duplication is par for the course in open
+source.
+
+*** Are proposals for documentation work eligible for Google Summer of Code?
+
+While we greatly appreciate the value of documentation, this program
+is an exercise in developing code; we can't accept proposals for
+documentation-only work at this time.
+
+*** How do payments work?
+
+Google will provide a stipend of 5500 USD per accepted student
+developer, of which 5000 USD goes to the student and 500 USD goes to
+the mentoring organization.
+
+Accepted students in good standing with their mentoring organization
+will receive a 500 USD stipend shortly after coding begins on May
+21, 2012. Students who receive passing mid-term evaluations will
+receive a 2250 USD stipend shortly after the mid-term evaluation
+deadline, July 13, 2012. Students who receive passing final
+evaluations and who have submitted their final program evaluations
+will receive a 2250 USD stipend shortly after the final evaluation
+deadline, August 24, 2012. Mentoring organizations must request their
+payments of 500 USD per student mentored by November 5, 2012.

org-contribute.org

@@ -168,7 +168,14 @@ commit message.
 For more significant contributions, the best way to submit patches is
 through public branches of your repository clone.
 
-1. Clone our git repository at =http://orgmode.org/w/org-mode.git=
+1. Clone our git repository at =http://orgmode.org/w/org-mode.git=.
+   You can clone using any of the commands below.
+
+   : git clone git://orgmode.org/org-mode.git
+   : git clone http://orgmode.org/org-mode.git
+
+   The url using the git protocol is preferred. If you are behind a
+   firewall that blocks ~git://~, you can use the http url.
 
 2. Create a repository that can be publicly accessed, for example on
    /GitHub/, /repo.or.cz/, or on your own server.
@@ -278,88 +285,91 @@ within GNU Emacs:
 1. Adam Elliott
 2. Andreas Burtzlaff
 3. Andreas Leha
-4. Andy Steward
-5. Anthony Lander
-6. Baoqiu Cui
-7. Barry Leonard Gidden
-8. Bastien Guerry
-9. Benjamin Andresen
-10. Bernd Grobauer
-11. Bernt Hansen
-12. Brian James Gough
-13. Carsten Dominik
-14. Charles Sebold
-15. Christian Egli
-16. Christian Moe
-17. Christopher League
-18. Christopher Miles Gray
-19. Christopher Suckling
-20. Dan Davison
-21. Daniel M German
-22. Daniel M. Hackney
-23. David Maus
-24. David O'Toole
-25. Ethan Ligon
-26. Eric S. Fraga
-27. Eric Schulte
-28. Erik Iverson
-29. Giovanni Ridolfi
-30. Ian Barton
-31. James TD Smith
-32. Jan Böker
-33. Jason Riedy
-34. Jeffrey Ryan Horn
-35. Joel Boehland
-36. John Wiegley
-37. Juan Pechiar
-38. Julian Gehring
-39. Julien Barnier
-40. Julien Danjou
-41. Konstantin Antipin
-42. Lawrence Mitchell
-43. Lennart Borgman
-44. Lukasz Stelmach
-45. Magnus Henoch
-46. Manuel Giraud
-47. Martin Pohlack
-48. Martyn Jago
-49. Matt Lundin
-50. Michael Brand
-51. Michael Gauland
-52. Michael Sperber
-53. Miguel A. Figueroa-Villanueva
-54. Mikael Fornius
-55. Nathan Neff
-56. Nicolas Goaziou
-57. Niels Giessen
-58. Noorul Islam K M
-59. Paul Sexton
-60. Peter Jones
-61. Pieter Praet
-62. Phil Jackson
-63. Philip Rooke
-64. Piotr Zielinski
-65. Puneeth Chaganti
-66. Richard Klinda
-67. Richard Riley
-68. Ross Patterson
-69. Russel Adams
-70. Sacha Chua
-71. Sebastian Rose
-72. Sebastien Vauban
-73. Sergey Litvinov
-74. Seweryn Kokot
-75. Stephen Eglen
-76. Thomas Holst
-77. Thorsten Jolitz
-78. Tassilo Horn
-79. Thomas Baumann
-80. Thomas S. Dye
-81. Tokuya Kameshima
-82. Tom Breton
-83. Tomas Hlavaty
-84. Ulf Stegemann
-85. Zhang Weize
+4. Andrzej Lichnerowicz
+5. Andy Steward
+6. Anthony Lander
+7. Baoqiu Cui
+8. Barry Leonard Gidden
+9. Bastien Guerry
+10. Benjamin Andresen
+11. Bernd Grobauer
+12. Bernt Hansen
+13. Brian James Gough
+14. Carsten Dominik
+15. Charles Sebold
+16. Christian Egli
+17. Christian Moe
+18. Christopher League
+19. Christopher Miles Gray
+20. Christopher Suckling
+21. Dan Davison
+22. Daniel M German
+23. Daniel M. Hackney
+24. David Maus
+25. David O'Toole
+26. Ethan Ligon
+27. Eric S. Fraga
+28. Eric Schulte
+29. Erik Iverson
+30. George Kettleborough
+31. Giovanni Ridolfi
+32. Ian Barton
+33. James TD Smith
+34. Jan Böker
+35. Jason Riedy
+36. Jeffrey Ryan Horn
+37. Joel Boehland
+38. John Wiegley
+39. Juan Pechiar
+40. Julian Gehring
+41. Julien Barnier
+42. Julien Danjou
+43. Konstantin Antipin
+44. Lawrence Mitchell
+45. Lennart Borgman
+46. Lukasz Stelmach
+47. Magnus Henoch
+48. Manuel Giraud
+49. Martin Pohlack
+50. Martyn Jago
+51. Matt Lundin
+52. Max Mikhanosha
+53. Michael Brand
+54. Michael Gauland
+55. Michael Sperber
+56. Miguel A. Figueroa-Villanueva
+57. Mikael Fornius
+58. Nathan Neff
+59. Nicolas Goaziou
+60. Niels Giessen
+61. Noorul Islam K M
+62. Paul Sexton
+63. Peter Jones
+64. Pieter Praet
+65. Phil Jackson
+66. Philip Rooke
+67. Piotr Zielinski
+68. Puneeth Chaganti
+69. Richard Klinda
+70. Richard Riley
+71. Ross Patterson
+72. Russel Adams
+73. Sacha Chua
+74. Sebastian Rose
+75. Sebastien Vauban
+76. Sergey Litvinov
+77. Seweryn Kokot
+78. Stephen Eglen
+79. Thomas Holst
+80. Thorsten Jolitz
+81. Tassilo Horn
+82. Thomas Baumann
+83. Thomas S. Dye
+84. Tokuya Kameshima
+85. Tom Breton
+86. Tomas Hlavaty
+87. Ulf Stegemann
+88. Zhang Weize
 
 ** Processing
 
@@ -377,6 +387,7 @@ change lines.  Details are given in [[http://www.gnu.org/prep/maintain/maintain.
 
 1. Robert P. Goldman
 2. Andy Lutomirski
+3. Adam Spiers
 
 (this list may be incomplete - please help to complete it)
 

org-dependencies.org

@@ -151,7 +151,7 @@ are various ways to allow it, some more convenient or more secure than
 others.
 
 If you use e.g. pdflatex from the command line, then in order to allow
-such external program execution, you just add the comman-line option
+such external program execution, you just add the command-line option
 --shell-escape:
 
 #+BEGIN_SRC sh

org-faq.org

@@ -4217,6 +4217,10 @@ directory accessible through, for example, /ssh/ and /scp/:
 (setq org-mobile-directory "/scpc:user@@remote.host:org/webdav/")
 #+end_src
 
+However, if you have configured ssh to use =ControlPersist=, due
+to [[http://article.gmane.org/gmane.emacs.tramp/7991][a bug with tramp and =ControlPersist=]] you may need to use =scpx=
+instead of =scp= as the /tramp/ transfer method.
+
 If Emacs cannot access the WebDAV directory directly using a /tramp/
 method, you can use a local directory for staging.  Other means must
 then be used to keep this directory in sync with the WebDAV directory.
@@ -4327,6 +4331,23 @@ please submit a bug report so that it can be fixed properly.
 See the "rather crude solution" posted in [[http://robert-adesam.blogspot.com/2011/07/orgmode-capture-to-insert-mairix-link.html][this blog entry]] by Robert
 Adesam.  
 
+* Google Summer of Code (GSoC)
+  :PROPERTIES:
+  :CUSTOM_ID: GSoC
+  :END:
+** Does Org Mode participate in GNU's application for the GSoC 2012?
+   :PROPERTIES:
+   :CUSTOM_ID: GSoC-2012
+   :END:
+
+#+index: GSoC 2012
+
+Org Mode will contribute project ideas to GNU's application as
+mentoring organisation in Google's Summer of Code 2012 (see Google's
+[[http://www.google-melange.com/document/show/gsoc_program/google/gsoc2012/faqs][faq]]). You can have a look at the [[file:org-contrib/gsoc2012/index.org][GSoC 2012 page]] on Worg for more
+information about the project itself, and how to participate as
+student or mentor. 
+
 * COMMENT Function to create =CUSTOM_ID=
 
 #+begin_src emacs-lisp

org-hacks.org

@@ -2747,22 +2747,36 @@ Tycho Garen sent [[http://comments.gmane.org/gmane.emacs.orgmode/44773][this]]:
 
 Everything is documented [[http://tychoish.com/code/org-mail/][here]].
 
-** hidestarsfile: "hidestars" for file
+** fileconversion
    :PROPERTIES:
-   :CUSTOM_ID: hidestarsfile
+   :CUSTOM_ID: fileconversion
    :END:
-#+index: Conversion!hidestarsfile
+#+index: Conversion!fileconversion
 
-Using hooks for file find and for file save I implemented hidestarsfile: On
-the fly and inspired by hidestars (a cleaner outline view:
-http://orgmode.org/manual/Clean-view.html )
-- remove the leading stars from all headings when writing a buffer to the
-  file
-- reinsert the leading stars when reading a file into the buffer
+Using hooks and on the fly
+- when writing a buffer to the file replace the stars from headings with a
+  file char
+- when reading a file into the buffer replace the file chars with stars for
+  headings
 
-Following is an example of the _file content_ first with leading stars as
-usual and below without leading stars through "#+STARTUP: odd hidestars
-hidestarsfile":
+To change to save an Org file in one of the formats or back just add or
+remove the keyword in the STARTUP line and save.
+
+Now you can also change to Fundamental mode to see how the file looks like
+on the level of the file, go back to Org mode, reenter Org mode or change to
+any other major mode and the conversion gets done whenever necessary.
+
+*** the format hidestarsfile
+    :PROPERTIES:
+    :CUSTOM_ID: hidestarsfile
+    :END:
+#+index: Conversion!fileconversion hidestarsfile
+
+This is like "a cleaner outline view":
+http://orgmode.org/manual/Clean-view.html
+
+Example of the _file content_ first with leading stars as usual and below
+without leading stars through "#+STARTUP: odd hidestars hidestarsfile":
 
 #+BEGIN_EXAMPLE
   #+STARTUP: odd hidestars
@@ -2790,93 +2804,189 @@ hidestarsfile":
 
 The latter is convenient for better human readability when an Org file,
 additionally to Emacs, is read with a file viewer or, for smaller edits,
-with an editor not capable of the Org file format. To change the format for
-the current file simply add or remove the keyword hidestarsfile in the
-STARTUP line.
+with an editor not capable of the Org file format.
 
-hidestarsfile is just a hack and can not become part of the Org core:
+hidestarsfile is a hack and can not become part of the Org core:
 - An Org file with hidestarsfile can not contain list items with a star as
   bullet due to the syntax conflict at read time.
 - An Org file with hidestarsfile can almost not be edited with an Org mode
   without added functionality of hidestarsfile as long as the file is not
   converted back.
 
-I am still uncertain about if this could be made Org-mode-specific to cover
-more use cases: When switching between Org mode and another major mode like
-Fundamental mode it would remove and reinsert the leading stars in the
-buffer itself, not only in the file. The current state is that it only
-reinserts the leading stars in the buffer and only removes them in the file.
-It does this regardless of the major mode, assuming that not-Org-files don't
-contain the "^#\+STARTUP:" hidestarsfile keywords. This is a simplification
-but I think it also helps to ensure better that it is less prone to the
-error of loosing track if it should now remove or reinsert and whether to
-mark not-modified. The org-mode-hook is called also when following a link
-and sometimes (source blocks?) more than once when just opening a file. I
-guess that this tracking could be even harder for leaving Org mode.
+*** the format markdownstarsfile
+    :PROPERTIES:
+    :CUSTOM_ID: markdownstarsfile
+    :END:
+#+index: Conversion!fileconversion markdownstarsfile
 
-#+BEGIN_SRC emacs-lisp
-  ;; don't match e. g. first word on line that is bold
-  (defconst my-heading-re "\\(\\*\\)\\( \\|$\\)")
+For "oddeven" you can use markdownstarsfile to be readable or even basically
+editable with Markdown (does not make much sense with "odd", see
+org-convert-to-odd-levels and org-convert-to-oddeven-levels for how to
+convert).
+
+Example of the _file content_:
+
+#+BEGIN_EXAMPLE
+  #+STARTUP: oddeven markdownstarsfile
+  # section level 1 with Org or Markdown numbered list
+    1. item
+  ## section level 2 with Org or Markdown unordered list
+     - item
+  ### section level 3 with Org or Markdown unordered list
+      + item
+  #### section level 4 with Org or Markdown unordered list
+       * item (avoid this type to be compatible with Org hidestarsfile)
+#+END_EXAMPLE
+
+An Org file with markdownstarsfile can not contain code comment lines
+prefixed with "#", even not when within source blocks.
+
+*** emacs-lisp code
+    :PROPERTIES:
+    :CUSTOM_ID: fileconversion-code
+    :END:
+#+index: Conversion!fileconversion emacs-lisp code
 
-  (defun my-org-hidestarsfile-p ()
-    "Check whether there is a STARTUP line with hidestarsfile."
+#+BEGIN_SRC emacs-lisp
+  ;; - fileconversion version 0.2
+  ;; - DISCLAIMER: Make a backup of your Org files before using
+  ;;   my-org-fileconv-*.
+  ;; - supported formats: hidestarsfile, markdownstarsfile
+
+  ;; design summary: fileconversion is a round robin of two states
+  ;; linked by two actions:
+  ;; - the level is "file" (encoded): my-org-fileconv-level-org-p is nil
+  ;; - replace file char with '*': my-org-fileconv-decode
+  ;; - the level is "Org" (decoded): my-org-fileconv-level-org-p is t
+  ;; - replace '*' with file char: my-org-fileconv-encode
+
+  (defvar my-org-fileconv-level-org-p nil
+    "Whether level of buffer is Org or only file.
+  nil means the level is file (encoded), non-nil means the level is Org
+  (decoded).")
+  (make-variable-buffer-local 'my-org-fileconv-level-org-p)
+  ;; survive a change of major mode that does kill-all-local-variables,
+  ;; e. g. reentering Org mode through “C-c C-c” on a STARTUP line
+  (put 'my-org-fileconv-level-org-p 'permanent-local t)
+
+  (add-hook 'org-mode-hook 'my-org-fileconv-init
+            ;; append to hook to have a chance that the last message
+            ;; left over in the minibuffer is from this function
+            t
+            nil)  ; global
+
+  (defun my-org-fileconv-init ()
+    (interactive)
+    (message (concat "INF: my-org-fileconv-init, buffer: "
+                     (buffer-name)))
+    (my-org-fileconv-decode)
+    ;; the hooks will be lost as needed at the moment when the major
+    ;; mode is changed, not permanent-local
+    (add-hook 'change-major-mode-hook 'my-org-fileconv-encode nil
+              t)   ; limit hook change local to buffer
+    (add-hook 'before-save-hook 'my-org-fileconv-encode nil
+              t)   ; limit hook change local to buffer
+    (add-hook 'after-save-hook 'my-org-fileconv-decode nil
+              t))  ; limit hook change local to buffer
+
+  (defun my-org-fileconv-re ()
+    "Check whether there is a STARTUP line for fileconversion.
+  If found then return the expressions required for the conversion."
     (save-excursion
       (beginning-of-buffer)
-      (re-search-forward "^#\\+STARTUP:.*\\bhidestarsfile\\b" nil t)))
-
-  (defun my-org-hidestarsfile-read ()
-    "In headings replace leading ' ' with '*'.
-  Add this together with my-org-hidestarsfile-write to the hooks
-  `find-file-hook', `before-save-hook' and `after-save-hook'."
-    (when (my-org-hidestarsfile-p)
-      (assert (not (buffer-modified-p)))
-      (let ((p (point)))  ; not a save-excursion due to error text
-        (beginning-of-buffer)
-        (when (re-search-forward (concat "^\\*+" my-heading-re) nil t)
-          (goto-char (match-beginning 0))
-          (error "ERR: read: syntax conflict at point"))
-        (beginning-of-buffer)
-        (while (re-search-forward (concat "^ +" my-heading-re) nil t)
-          (goto-char (match-beginning 0))
-          (while (< (point) (match-beginning 1))
-            (insert ?*)
-            (delete-char 1)))
-        (goto-char p))
-      ;; The changes to the buffer until here are not regarded by
-      ;; ediff-files because the first call to diff is made with the
-      ;; files directly. Only ediff-update-diffs or ediff-buffers writes
-      ;; the buffers to temp files and then calls diff with them.
-      ;; Workarounds:
-      ;; - after ediff-files first do a "!" (ediff-update-diffs) in the
-      ;;   "*Ediff Control Panel*"
-      ;; - instead of using ediff-files first open the files and then
-      ;;   run ediff-buffers (better for e. g. a script that takes
-      ;;   two files as arguments and uses "emacs --eval")
-      (not-modified)))
-
-  (defun my-org-hidestarsfile-write ()
-    "In headings replace leading '*' with ' '.
-  Add this together with my-org-hidestarsfile-read to the hooks
-  `find-file-hook', `before-save-hook' and `after-save-hook'."
-    (when (and (my-org-hidestarsfile-p)
-               (buffer-modified-p))
-      (let ((p (point)))  ; not a save-excursion due to error text
-        (beginning-of-buffer)
-        (when (re-search-forward (concat "^ +" my-heading-re) nil t)
-          (goto-char (match-beginning 0))
-          (error "ERR: write: syntax conflict at point"))
-        (beginning-of-buffer)
-        (while (re-search-forward (concat "^\\*+" my-heading-re) nil t)
-          (goto-char (match-beginning 0))
-          (while (< (point) (match-beginning 1))
-            (insert ?\ )
-            (delete-char 1)))
-        (goto-char p)))
+      (let (re-list (count 0))
+        (while (re-search-forward "^#\\+STARTUP:" nil t)
+          (when (string-match-p "\\bhidestarsfile\\b"
+                                (thing-at-point 'line))
+            ;; exclude e. g.:
+            ;; - line starting with star for bold emphasis
+            ;; - line of stars to underline section title in loosely
+            ;;   quoted ASCII style (star at end of line)
+            (setq re-list '("\\(\\* \\)"  ; common-re
+                            ?\ ))         ; file-char
+            (setq count (1+ count)))
+          (when (string-match-p "\\bmarkdownstarsfile\\b"