lots of fixes

28 files changed, 312 insertions, 274 deletions

diff --git a/root/articles/mmmfs/$order b/root/articles/mmmfs/$order
index dd9746b..10dcf5c 100644
--- a/root/articles/mmmfs/$order
+++ b/root/articles/mmmfs/$order
@@ -1,3 +1,4 @@
+title
 abstract
 motivation
 historical-approaches
@@ -7,4 +8,5 @@ examples
 evaluation
 conclusion
 references
+statement-of-originality
 ba_log
diff --git a/root/articles/mmmfs/ba_log/print: text$moonscript -> fn -> mmm$dom.moon b/root/articles/mmmfs/ba_log/print: text$moonscript -> fn -> mmm$dom.moon
index 83c0c2c..d23edbb 100644
--- a/root/articles/mmmfs/ba_log/print: text$moonscript -> fn -> mmm$dom.moon
+++ b/root/articles/mmmfs/ba_log/print: text$moonscript -> fn -> mmm$dom.moon
@@ -4,6 +4,8 @@ import ropairs from require 'mmm.ordered'
 
 =>
   div {
+    class: 'print-ownpage'
+
     h1 link_to @, "appendix: project log"
     table.unpack for post in *@children
       continue if post\get 'hidden: bool'
diff --git a/root/articles/mmmfs/evaluation/text$markdown+sidenotes.md b/root/articles/mmmfs/evaluation/text$markdown+sidenotes.md
index f44e18b..1c8fda7 100644
--- a/root/articles/mmmfs/evaluation/text$markdown+sidenotes.md
+++ b/root/articles/mmmfs/evaluation/text$markdown+sidenotes.md
@@ -7,7 +7,7 @@ and evaluate them with regard to the framework derived in the corresponding sect
 
 ### publishing and blogging
 Since mmmfs has grown out of the need for a versatile CMS for a personal publishing website, it is not surprising to
-to see that it is still up to that job. Nevertheless it is worth taking a look at its strengths and weaknesses in this
+see that it is still up to that job. Nevertheless it is worth taking a look at its strengths and weaknesses in this
 context:
 
 The system has proven itself perfect for publishing small- and medium-size articles and blog posts, especially for its
@@ -15,13 +15,14 @@ ability to flexibly transclude content from any source. This includes diagrams (
 videos (as in the documentation in the appendix), but also less conventional media such as
 interactive diagrams<mmm-embed path="../references/aspect-ratios" wrap="sidenote"></mmm-embed> or twitter postings.
 
-On the other hand, the development of the technical framework for this very thesis has posed greater challenges.
+<!-- @TODO -->
+On the other hand, the development of the technical framework for this thesis has posed greater challenges.
 In particular, the implementation of the reference and sidenote systems are brittle and uninspiring.
 
 This is mostly due to the approach of splitting up the thesis into a multitude of fileders, and the current lack of
 mechanisms to re-capture information spread throughout the resulting history effectively.
 Another issue is that the system is currently based on the presumption that content can and should be interpreted
-separate from its parent and context in most cases. This has made the implementation of sidenotes less idiomatic
+separately from its parent and context in most cases. This has made the implementation of sidenotes less idiomatic
 than initially anticipated.
 
 ### pinwall
@@ -71,20 +72,20 @@ The parts of the code dealing with the content are essentially identical, except
 more general `mmm/dom` type-interface, allowing for a greater variety of types of content to be used as slides.
 
 ## general concerns
-While the system has proven pretty successfuly and moldable to the different use-cases that it has been tested in,
+While the system has proven pretty successful and moldable to the different use-cases that it has been tested in,
 there are also limitations in the proposed system that have become obvious in developing and working with the system.
 Some of these have been anticipated for some time and concrete research directions for solutions are apparent,
 while others may be intrinsic limitations in the approach taken.
 
 ### global set of converts
-In the current system, there exists only a single, global set of *converts* that can be potentially applied
-to facets anywhere in the system.
+In the current system, there is only a single, global set of *converts* that can be potentially applied to facets
+anywhere in the system.
 Therefore it is necessary to encode behaviour directly (as code) in facets wherever exceptional behaviour is required.
 For example if a fileder conatining multiple images wants to provide custom UI for each image when viewed independently,
 this code has to either be attached to every image individually (and redundantly), or added as a global convert.
 To make sure this convert does not interfere with images elsewhere in the system, it would be necessary to introduce
-a new type and change the images to use it, which may present more problems yet and works against the principle of
-compatibility the system has been constructed for.
+a new type and change the images to use it, which may present even more problems, and works against the principle of
+compatibility that the system has been constructed for.
 
 A potential direction of research in the future is to allow specifying *converts* as part of the fileder tree.
 Application of *converts* could then be scoped to their fileders' subtrees, such that for any facet only the *converts*
@@ -100,7 +101,7 @@ the hierarchical organization of data, thereby exacerbating the limits of hierar
 ### code outside of the system
 At the moment, a large part of the mmmfs codebase is still separate from the content, and developed outside of mmmfs
 itself. This is a result of the development process of mmmfs and was necessary to start the project as the filesystem
-itself matured, but has become a limitation of the user experience now: Potential users of mmmfs would generally start
+itself matured, but has now become a limitation of the user experience: potential users of mmmfs would generally start
 by becoming familiar with the operation of mmmfs from within the system, as this is the expected (and designated)
 experience developed for them. All of the code that lives outside of the mmmfs tree is therefore invisible and opaque
 to them, actively limiting their understanding, and thereby the customizability, of the system.
@@ -110,8 +111,8 @@ This weakness represents a failure to (fully) implement the quality of a "Living
 
 In general however, some portion of code may always have to be left outside of the system.
 This also wouldn't necessarily represent a problem, but in this case it is particularily relevant
-for the global set of *converts* (see above), as well as the layout used to render the web view, 
-both of which are expected to undergo changes as users adapt the system to their own content types and
+for the global set of *converts* (see above), as well as the layout used to render the web view. 
+Both of these are expected to undergo changes as users adapt the system to their own content types and
 domains of interest, as well as their visual identity, respectively.
 
 ### type system
@@ -134,35 +135,32 @@ In much the same way that the application-centric paradigm alienates users from
 and feeling of ownership of their data by overemphasizing the tools in between,
 the automagical coercion of data types introduces distance between the user and
 an understanding of the data in the system.
-This poses a threat to the transparency of the system, and a potential lack of the quality of "Embodiment" (see above).
+This poses a threat to the transparency of the system, and potentially a lack of the "Embodiment" quality (see above).
 
 Potential solutions could be to communicate the conversion path clearly and explicitly together with the content,
 as well as making this display interactive to encourage experimentation with custom conversion queries.
-Emphasising the conversion process more strongly in this way might be able to turn this feature from an opaque
-hindrance into a transparent tool using careful UX and UI design.
+Emphasising the conversion process more strongly in this way might be a way to turn this feature from an opaque
+hindrance into a transparent tool. This should represent a challenge mostly in terms of UX and UI design.
 
 ### editing
-Because many *converts* are not necessarily reversible,
-it is very hard to implement generic ways of editing stored data in the same format it is viewed.
-For example, the system trivially converts markdown-formatted text sources into viewable HTML markup,
-but it is hardly possible to propagate changes to the viewable HTML back to the markdown source.
-This particular instance of the problem might be solvable using a Rich-Text editor, but the general problem
-worsens when the conversion path becomes more complex:
-If the markdown source was fetched via HTTP from a remote URL (e.g. if the facet's type was `URL -> text/markdown`),
-it is not possible to edit the content at all, since the only data owned by the system is the URL string itself,
-which is not part of the viewable representation at all.
-Similarily, when viewing output that is generated by code (e.g. `text/moonscript -> mmm/dom`),
-the code itself is not visible to the user when interacting with the viewable representation,
-and if the user wishes to change parts of the representation the system is unable to relate these changes to elements
-of the code or assist the user in doing so.
-
-However even where plain text is used and edited, a shortcoming of the current approach to editing is evident:
-The content editor is wholly separate from the visible representation, and only facets of the currently viewed
-fileder can be edited. This means that content cannot be edited in its context, which is particularily annoying
-due to the fragmentation of content that mmmfs encourages. 
-
-As a result, interacting with the system at large is still a very different experience than  editing content (and
+Because many *converts* are not necessarily reversible, it is very hard to implement generic ways of editing stored data
+in the same format it is viewed. For example, the system trivially converts markdown-formatted text sources into
+viewable HTML markup, but it is hardly possible to propagate changes to the viewable HTML back to the markdown source.
+This particular instance of the problem might be solvable using a Rich-Text editor, but the general problem worsens when
+the conversion path becomes more complex: If the markdown source was fetched via HTTP from a remote URL (e.g. if the
+facet's type was `URL -> text/markdown`), it is not possible to edit the content at all, since the only data owned by
+the system is the URL string itself, which is not part of the viewable representation. Similarily, when viewing output
+that is generated by code (e.g. `text/moonscript -> mmm/dom`), the code itself is not visible to the user, and if the
+user wishes to change parts of the representation, the system is unable to relate these changes to elements of the code
+or assist the user in doing so.
+
+However, even where plain text is used and edited, a shortcoming of the current approach to editing is evident:
+The content editor is wholly separate from the visible representation, and only facets of the currently viewed fileder
+can be edited. This means that content cannot be edited in its context, which is exacerbated by the extreme
+fragmentation of content that mmmfs encourages. 
+
+As a result, interacting with the system at large is still a very different experience from editing content (and
 thereby extending the system) in it. This is expected to represent a major hurdle for users getting started with the
-system, and is a major shortcoming in enabling end-user programming as set as a goal for
-this project. A future iteration should take care to reconsider how editing can be integrated more holistically
-with the other core concepts of the design.
+system, and is a major shortcoming in enabling end-user programming, as set as a goal for this project.
+A future iteration should carefully reconsider how editing could be integrated more holistically with the other core
+concepts of the design.
diff --git a/root/articles/mmmfs/examples/$order b/root/articles/mmmfs/examples/$order
index 348f5fe..4ee3140 100644
--- a/root/articles/mmmfs/examples/$order
+++ b/root/articles/mmmfs/examples/$order
@@ -1,6 +1,5 @@
 language_support
 image
 markdown
-empty
 gallery
 pinwall
diff --git a/root/articles/mmmfs/examples/empty/title: text$plain b/root/articles/mmmfs/examples/empty/title: text$plain
deleted file mode 100644
index 911f98b..0000000
--- a/root/articles/mmmfs/examples/empty/title: text$plain
+++ /dev/null
@@ -1 +0,0 @@
-Hey I'm an almost empty Fileder.
diff --git a/root/articles/mmmfs/examples/gallery/preview: text$moonscript -> fn -> mmm$dom.moon b/root/articles/mmmfs/examples/gallery/preview: text$moonscript -> fn -> mmm$dom.moon
deleted file mode 100644
index 5285629..0000000
--- a/root/articles/mmmfs/examples/gallery/preview: text$moonscript -> fn -> mmm$dom.moon
+++ /dev/null
@@ -1,7 +0,0 @@
-import div, img, br from require 'mmm.dom'
-
-=> div {
-  'the first pic as a little taste:',
-  br!,
-  img src: @children[1]\get 'preview', 'URL -> image/png'
-}
diff --git a/root/articles/mmmfs/examples/gallery/title: text$plain b/root/articles/mmmfs/examples/gallery/title: text$plain
index ad74eec..2e9ef34 100644
--- a/root/articles/mmmfs/examples/gallery/title: text$plain
+++ b/root/articles/mmmfs/examples/gallery/title: text$plain
@@ -1 +1 @@
-A Gallery of 25 random pictures, come on in!
+a gallery of images
diff --git a/root/articles/mmmfs/examples/image/preview: text$moonscript -> fn -> mmm$dom.moon b/root/articles/mmmfs/examples/image/preview: text$moonscript -> fn -> mmm$dom.moon
deleted file mode 100644
index 6c431d0..0000000
--- a/root/articles/mmmfs/examples/image/preview: text$moonscript -> fn -> mmm$dom.moon
+++ /dev/null
@@ -1,5 +0,0 @@
-import img from require 'mmm.dom'
-
--- look for main content with 'URL to png' type
--- and wrap in an mmm/dom image tag
-=> img src: @gett 'URL -> image/png'
diff --git a/root/articles/mmmfs/examples/image/title: text$plain b/root/articles/mmmfs/examples/image/title: text$plain
index 60a556f..dca924f 100644
--- a/root/articles/mmmfs/examples/image/title: text$plain
+++ b/root/articles/mmmfs/examples/image/title: text$plain
@@ -1 +1 @@
-Hey I'm like a link to a picture or smth
+link to a remote image
diff --git a/root/articles/mmmfs/examples/intro: text$markdown+sidenotes.md b/root/articles/mmmfs/examples/intro: text$markdown+sidenotes.md
index cce348c..709da5c 100644
--- a/root/articles/mmmfs/examples/intro: text$markdown+sidenotes.md
+++ b/root/articles/mmmfs/examples/intro: text$markdown+sidenotes.md
@@ -16,16 +16,17 @@ and doesn't render as a paragraph but rather just a line of text.
 This makes it suitable for denoting formatted-text titles and other small strings of text. 
 
 The problem of embedding other content together with text comfortably is also solved easily,
-becase Markdown allows embedding arbitrary HTML in the document.
+because Markdown allows embedding arbitrary HTML in the document.
 This made it possible to define a set of pseudo-HTML elements in the Markdown-convert,
 `<mmm-embed>` and `<mmm-link>`, which respectively embed and link to other content native to mmm.
 
 ### scientific publishing
-<div class="sidenote">
+<div class="sidenote" style="margin-top: 1.25rem">
 One of the 'standard' solutions, <a href="https://www.latex-project.org/">LaTeX</a>,
 is arguably at least as complex as the mmm system proposed here, but has a much narrower scope,
 since it does not support interaction.
 </div>
+
 Scientific publishing is notoriously complex, involving not only the transclusion of diagrams
 and other media, but generally requiring precise and consistent control over formatting and layout.
 Some of these complexities are tedious to manage, but present good opportunities for programmatic
@@ -43,9 +44,9 @@ type to convert to a full reference format (to `mmm/dom`) and to an inline side-
 
 For convenience, a convert from the `URL -> cite/acm` type has been provided to `URL -> text/bibtex`,
 which generates links to the ACM Digital Library<mmm-embed path="../references/acm-dl" wrap="sidenote"></mmm-embed>
-API for accessing BibTeX citations for documents in the library.
-This means that it is enough to store the link to the ACM DL entry in mmmfs,
-and the reference will automatically be fetched (and track potential remote corrections).
+API for accessing BibTeX citations for documents in the library. This means that it is enough to store the link to the
+ACM DL entry in mmmfs, and the reference will automatically be fetched, and therefore stay up to date with potential
+remote corrections.
 
 ## pinwall
 In many situations, in particular for creative work, it is often useful to compile resources of
@@ -62,14 +63,14 @@ which enumerates the list of children, wraps each in such a rectangular containe
 and outputs the list of containers as DOM elements.
 
 The position and size of each panel are stored in an ad-hoc facet, encoded in the JSON data format:
-`pinwall_info: text/json`. This facet can then set on each child and accessed whenever the script is called
+`pinwall_info: text/json`. Such a facet is set on each child and read whenever the script is called
 to render the children, plugging the values within the facet into the visual styling of the document.
 
 The script can also set event handlers that react to user input while the document is loaded,
 and allow the user to reposition and resize the individual pinwall items by clicking and dragging
 on the upper border or lower right-hand corner respectively.
 Whenever a change is made the event handler can then update the value in the `pinwall_info` facet,
-so that the script places the content at the updated position and size next time it is invoked.
+so that the updated position and size are stored for the next time the pinwall is opened.
 
 ## slideshow
 Another common use of digital documents is as aids in a verbal presentation.
@@ -84,8 +85,10 @@ It also allows putting the browser into fullscreen mode to maximise screenspace
 of the website that may distract from the presentation, and register an event handler for keyboard accelerators
 for moving through the presentation.
 
-Finally the script simply embeds the first of its child-fileders into the viewport rect.
-One the current slide is changed, the next embedded child is simply chosen.
+Finally the script simply embeds the first of its child-fileders into the viewport rectangle.
+Once the current slide is changed, the next embedded child is simply chosen.
 
+<!--
 ## code documentation
 /meta/mmm.dom/:%20text/html+interactive
+-->
diff --git a/root/articles/mmmfs/examples/markdown/preview: text$markdown.md b/root/articles/mmmfs/examples/markdown/preview: text$markdown.md
deleted file mode 100644
index 4b38ef2..0000000
--- a/root/articles/mmmfs/examples/markdown/preview: text$markdown.md
+++ /dev/null
@@ -1,6 +0,0 @@
-See I have like
-
-- a list of things
-- (two things)
-
-and some bold **text** and `code tags` with me.
diff --git a/root/articles/mmmfs/examples/markdown/text$markdown.md b/root/articles/mmmfs/examples/markdown/text$markdown.md
new file mode 100644
index 0000000..880eedb
--- /dev/null
+++ b/root/articles/mmmfs/examples/markdown/text$markdown.md
@@ -0,0 +1,20 @@
+This is a markdown document rendered using [marked][marked] on the client, and [discount][discount] on the server.
+All Markdown features are supported, for example there is support for lists...
+
+- a list of things
+- (two things)
+
+...and syntax-highlighted code tags:
+
+```
+print "Hello World"
+```
+
+Since Markdown supports inline HTML, mmmfs shorthands can also be used to embed and reference content from elsewhere in
+the system. For example, the title of this fileder can be embedded using
+`<mmm-embed facet="title"></mmm-embed>`:
+
+<mmm-embed facet="title"></mmm-embed>
+
+[marked]: https://marked.js.org/
+[discount]: https://luarocks.org/modules/craigb/discount
diff --git a/root/articles/mmmfs/examples/markdown/title: text$plain b/root/articles/mmmfs/examples/markdown/title: text$plain
index 319068d..7915148 100644
--- a/root/articles/mmmfs/examples/markdown/title: text$plain
+++ b/root/articles/mmmfs/examples/markdown/title: text$plain
@@ -1 +1 @@
-  I'm not even five lines of markdown but i render myself!
+markdown content
diff --git a/root/articles/mmmfs/examples/pinwall/title: text$plain b/root/articles/mmmfs/examples/pinwall/title: text$plain
index 9d29c5d..c629992 100644
--- a/root/articles/mmmfs/examples/pinwall/title: text$plain
+++ b/root/articles/mmmfs/examples/pinwall/title: text$plain
@@ -1 +1 @@
-A pinwall
+a pinwall
diff --git a/root/articles/mmmfs/examples/text$moonscript -> fn -> mmm$dom.moon b/root/articles/mmmfs/examples/text$moonscript -> fn -> mmm$dom.moon
index c79ffcf..1401e95 100644
--- a/root/articles/mmmfs/examples/text$moonscript -> fn -> mmm$dom.moon
+++ b/root/articles/mmmfs/examples/text$moonscript -> fn -> mmm$dom.moon
@@ -13,7 +13,7 @@
     title = child\gett 'title', 'text/plain'
 
     -- get 'preview' as a DOM description (nil if no value or conversion possible)
-    content = child\get 'preview', 'mmm/dom'
+    -- content = child\get 'preview', 'mmm/dom'
 
     -- div {
     --   h4 title, style: { margin: 0, cursor: 'pointer' }, onclick: -> BROWSER\navigate child.path
@@ -31,10 +31,15 @@
 
     li link_to child
 
-  content = ul for child in *@children
-    preview child
+  examples = div {
+    style:
+      position: 'relative'
+      'margin-top': '4rem'
 
-  -- table.insert content, 1, (@gett 'intro: mmm/dom')
-  -- div content
+    div "The online version is available at ", (a "s-ol.nu/ba", href: 'https://s-ol.nu/ba'), ".", class: 'sidenote'
+    "The following examples can be viewed and inspected in the interactive version online:"
+    ul for child in *@children
+      preview child
+  }
 
-  div (@gett 'intro: mmm/dom'), content
+  div (@gett 'intro: mmm/dom'), examples
diff --git a/root/articles/mmmfs/framework/text$markdown+sidenotes.md b/root/articles/mmmfs/framework/text$markdown+sidenotes.md
index 48e6a2c..f62c581 100644
--- a/root/articles/mmmfs/framework/text$markdown+sidenotes.md
+++ b/root/articles/mmmfs/framework/text$markdown+sidenotes.md
@@ -22,16 +22,16 @@ end-user programming<mmm-embed path="../references/inkandswitch" wrap="sidenote"
   use of the tools and general 'passive' use of containing system at large. 
 
 These serve as guiding principles for the design and evaluation of computer systems for end-users, but are by nature
-very abstract. The following properties are therefore derived as more concrete proposals based on some more specific
+very abstract. The following properties are therefore derived as more concrete proposals based on more specific
 constraints: namely the construction of a system for end-users to keep, structure and display personal information and
-thoughts in.
+thoughts.
 
 modularity
 ----------
 
 The *UNIX Philosophy*<mmm-embed path="../references/unix" wrap="sidenote"></mmm-embed> describes the software design
 paradigm pioneered in the creation of the Unix operating system at the AT&T Bell Labs research center in the 1960s. The
-concepts are considered quite influental and are still notably applied in the Linux community. Many attempts at
+concepts are considered quite influential and are still notably applied in the Linux community. Many attempts at
 summaries exist, but the following includes the pieces that are especially relevant even today:
 
 > Even though the UNIX system introduces a number of innovative programs and techniques, no single program or idea makes
@@ -47,13 +47,13 @@ in such a way that it is easy to integrate for the user later. Assembling the sy
 interacting pieces also enables future growth and customization, since pieces may be swapped out with customized or
 alternate software at any time.
 
-Settling on a specific modular design model, and reifying other components of a system in terms of it also corresponds
+Settling on a specific modular design model, and reifying other components of a system in terms of it, also corresponds
 directly to the concept of *Embodiment* described by Ink & Switch.
 
 content transclusion
 --------------------
 
-The strengths of modular architectures should similarily also extend into the way the system will be used by users.
+The strengths of modular architectures should similarily extend also into the way the system will be used by users.
 If users are to store their information and customized behaviour in such an architecture, then powerful tools need to be
 present in order to assemble more complex solutions out of such parts. Therefore static content should be able to be
 linked to (as envisioned for the *Memex*, see above), but also to be <mmm-embed wrap="marginnote"
diff --git a/root/articles/mmmfs/historical-approaches/text$markdown+sidenotes.md b/root/articles/mmmfs/historical-approaches/text$markdown+sidenotes.md
index dff153a..8829f69 100644
--- a/root/articles/mmmfs/historical-approaches/text$markdown+sidenotes.md
+++ b/root/articles/mmmfs/historical-approaches/text$markdown+sidenotes.md
@@ -1,7 +1,7 @@
 historical approaches
 =====================
 
-Two of the earliest wholistic computing systems, the Xerox Alto and Xerox Star, both developed at Xerox PARC and
+Two of the earliest holistic computing systems, the Xerox Alto and Xerox Star, both developed at Xerox PARC and
 introduced in the 70s and early 80s, pioneered not only graphical user-interfaces, but also the "Desktop Metaphor".
 The desktop metaphor presents information as stored in "Documents" that can be organized in folders and on the
 "Desktop". It invokes a strong analogy to physical tools. One of the differences between the Xerox Star system and
@@ -39,19 +39,21 @@ The *Memex* is a hypothetical device and system for knowledge management. Propos
 path="../references/memex" wrap="sidenote"></mmm-embed>, the concept predates much of the technology that later was used
 to implement many parts of the vision.
 
+<!--
 While the article extrapolates from existing technology at the time, describing at times
 very concrete machinery based on microfilm and mechanical contraptions, many of the conceptual predictions became
 true or inspired  ....
+-->
 
 One of the most innovative elements of Bush's predictions is the idea of technologically cross-referenced and
 connected information, which would later be known and created as *hypertext*. While hypertext powers the majority of
 today's internet, many of the advantages that Bush imagined have not carried over into the personal use of computers.
-There are very few tools for creating personal, highly-interconnected knowledgebases, even though this is technically
-feasible, and a proven concept (exemplified for example by the massively successful online encyclopedia
+There are very few tools for creating personal, highly-interconnected knowledgebases, even though it is technologically
+feasible and a proven concept (exemplified for example by the massively successful online encyclopedia
 *Wikipedia*<mmm-embed path="../references/wikipedia" wrap="sidenote"></mmm-embed>).
 
 While there are little such tools available today, one of the systems that could be said to have come closest to a
-practical implementation of such a Memex-inspired system for personal use might be Apple's *HyperCard*.
+practical implementation of a Memex-inspired system for personal use might be Apple's *HyperCard*.
 
 In a live demonstration<mmm-embed path="../references/hypercard" wrap="sidenote"></mmm-embed>, the creators of the
 software showcase a system of stacks of cards that together implement, amongst others, a calendar (with yearly and
@@ -62,8 +64,8 @@ automatically looking up the card corresponding to a person's first name from a
 different card.
 
 Alongside Spreadsheets, *HyperCard* remains one of the most successful implementations of end-user programming, even
-today. While it's technical abilities have been long matched and surpassed by other software (such as the ubiquitous
-*Hypertext Markup Language*, HTML), these technical successors have failed the legacy of *HyperCard* as an end-user
-tool: while it is easier than ever to publish content on the web (through various social media and microblogging
-services), the benefits of hypermedia as a customizable medium for personal management have nearly vanished.
-End-users do not create hypertext anymore.
+today. While its technical abilities have been long matched and surpassed by other software (such as the ubiquitous
+*Hypertext Markup Language*, HTML and the associated programming language *JavaScript*), these technical successors have
+failed the legacy of *HyperCard* as an end-user tool: While it is easier than ever to publish content on the web
+(through various social media and microblogging services), the benefits of hypermedia as a customizable medium for
+personal management have nearly vanished. End-users do not create hypertext anymore.
diff --git a/root/articles/mmmfs/mmmfs/text$markdown+sidenotes.md b/root/articles/mmmfs/mmmfs/text$markdown+sidenotes.md
index bf1ed9b..c2bbee5 100644
--- a/root/articles/mmmfs/mmmfs/text$markdown+sidenotes.md
+++ b/root/articles/mmmfs/mmmfs/text$markdown+sidenotes.md
@@ -20,17 +20,18 @@ Like many data storage models it is based fundamentally on the concept of a hier
 <mmm-embed path="tree_mainstream">schematic view of an example tree in a mainstream filesystem</mmm-embed>
 
 In common filesystems, as pictured, data can be organized hierarchically into *folders* (or *directories*),
-which serve only as containers of *files*, in which data is actually stored.
-While *directories* are fully transparent to both system and user (they can be created, browser, listed and viewed by both),
-*files* are, from the system perspective, mostly opaque and inert blocks of data.
+which serve only as containers of *files*, in which data is actually stored. While *directories* are fully transparent
+to both system and user (they can be created, browsed, listed and viewed by both), *files* are, from the system
+perspective, mostly opaque and inert blocks of data.
 
 Some metadata, such as file size and access permissions, is associated with each file,
 but notably the type of data is generally not actually stored in the filesystem,
 but determined loosely based on multiple heuristics depending on the system and context.
 Some notable mechanism are:
 
-- Suffixes in the name are often used to indicate what kind of data a file should contain. However there is no standardization
-- over this, and often a suffix is used for multiple incompatible versions of a file-format.
+- Suffixes at the end of the filename are often used to indicate which kind of data a file contains. However there is no
+  centralized standardization of suffixes, and often one suffix is used for multiple incompatible versions of a
+  file-formats, or multiple suffixes are used interchangeably for one format.
 - Many file-formats specify a specific data-pattern either at the very beginning or very end of a given file.
   On unix systems the `libmagic` database and library of these so-called *magic constants* is commonly used to guess
   the file-type based on these fragments of data.
@@ -41,44 +42,50 @@ Some notable mechanism are:
 It should be clear already from this short list that to mainstream operating systems, as well as the applications
 running on them, the format of a file is almost completely unknown and at best educated guesses can be made.
 
-Because these various mechanisms are applied at different times by the operating system and applications,
-it is possible for files to be labelled as or considered as being in different formats at the same time by different
-components of the system.
-<mmm-embed path="confusion" wrap="marginnote" style="margin-top: -5rem;"></mmm-embed>
+<mmm-embed path="confusion" wrap="marginnote" style="margin-top: -3rem;"></mmm-embed>
+Because these various mechanisms are applied at different times by the operating system and applications, it is possible
+for files to be labelled or considered as being in different formats at the same time by different components of the
+system.
+
 This leads to confusion about the factual format of data among users, but can also pose a serious security risk:
 Under some circumstances it is possible that a file contains maliciously-crafted code and is treated as an executable
 by one software component, while a security mechanism meant to detect such code determines the same file to be a
 legitimate image<mmm-embed path="../references/poc-or-gtfo" wrap="sidenote"></mmm-embed> (the file may in fact be valid
 in both formats).
 
-In mmmfs, the example above might look like this instead:  
+In mmmfs, the example above might look like this instead:
 <mmm-embed path="tree_mmmfs">schematic view of an example mmmfs tree</mmm-embed>
 
-Superficially, this may look quite similar: there is still only two types of nodes (referred to as *fileders* and *facets*),
-and again one of them, the *fileders* are used only to hierarchically organize *facets*.
-Unlike *files*, *factes* don't only store a freeform *name*, there is also a dedicated *type* field associated with every *facet*,
-that is explicitly designed to be understood and used by the system.
+Superficially, this may look quite similar: there is still only two types of nodes (referred to as *fileders* and
+*facets*), and again one of them, the *fileders* are used only to hierarchically organize *facets*. Unlike *files*,
+*factes* don't only store a freeform *name*, there is also a dedicated *type* field associated with every *facet*, that
+is explicitly designed to be understood and used by the system.
 
-Despite the similarities, the semantics of this system are very different:
-In mainstream filesystems, each *file* stands for itself only;
-i.e. in a *directory*, no relationship between *files* is assumed by default,
-and files are most of the time read or used outside of the context they exist in in the filesystem.
+Despite the similarities, the semantics of this system are very different: In mainstream filesystems, each *file* stands
+for itself only; i.e. in a *directory*, no relationship between *files* is assumed by default, and files are most of the
+time read or used outside of the context they exist in in the filesystem.
 
 In mmmfs, a *facet* should only ever be considered an aspect of its *fileder*, and never as separate from it.
-A *fileder* can contain multiple *facets*, but they are meant to be alternate or equivalent representations of the *fileder* itself.
-Though for some uses it is required, software in general does not have to be directly aware of the *facets* existing within a *fileder*,
-rather it assumes the presence of content in the representation that it requires, and simple requests it.
-The *Type Coercion Engine* (see below) will then attempt to satisfy this request based on the *facets* that are in fact present.
+A *fileder* can contain multiple *facets*, but they are meant to be alternate or equivalent representations of the
+*fileder* itself. Though for some uses it is required, software in general does not have to be directly aware of the
+*facets* existing within a *fileder*, rather it assumes the presence of content in the representation that it requires,
+and simple requests it. The *Type Coercion Engine* (see below) will then attempt to satisfy this request based on the
+*facets* that are in fact present.
 
-Semantically a *fileder*, like a *directory*, also encompasses all the other *fileders* nested within it (recursively).
-Since *fileders* are the primary unit of data to be operated upon, *fileder* nesting emerges as a natural way of structuring complex data,
-both for access by the system and applications, as well as the user themself.
+Semantically a *fileder*, like a *directory*, also encompasses all the other *fileders* nested within itself
+(recursively). Since *fileders* are the primary unit of data to be operated upon, *fileder* nesting emerges as a natural
+way of structuring complex data, both for access by the system and its components, as well as the user themself.
 
 ## the type system & coercion engine
-As mentioned above, *facets* store data alongside its *type*, and when applications require data from a *fileder*,
-they specify the *type* (or the list of *types*) that they require the type to be in.
-
-In the current iteration of the type system, types are simple strings of text and loosely based on MIME-types [TOOD: quote RFC?].
+As mentioned above, *facets* store data alongside its *type*, and when a component of the system requires data from a
+*fileder*, it has to specify the *expected type* (or a list of these) that it requires the data to be in. The system
+then attempts to coerce one of the existing facets into the *expected type*, if possible. This process can involve many
+steps such as converting between similar file formats, running executable code stored in a facet, or fetching remote
+content. The component that requested the data is isolated from this process and does not have to deal with any of the
+details.
+
+In the current iteration of the type system, types are simple strings of text and loosely based on MIME-types<mmm-embed
+path="../references/mime-types" wrap="sidenote"></mmm-embed>.
 MIME types consist of a major- and minor category, and optionally a 'suffix'.
 Here are some common MIME-types that are also used in mmmfs:
 
@@ -87,29 +94,29 @@ Here are some common MIME-types that are also used in mmmfs:
 - `image/png`
 - `image/jpeg`
 
-While these types allow some amount of specifity, they fall short of describing their content especially in cases where formats overlap:
-Source code is often distributed in `.tar.gz` archive files (directory-trees that are first bundled into an `application/x-tar` archive,
-and then compressed into an `application/gzip` archive).
-Using either of these two types is either incorrect or insufficient information to properly treat and extract the contained data.
+While these types allow some amount of specifity, they fall short of describing their content especially in cases where
+formats overlap: Source code for example is often distributed in `.tar.gz` archive files (directory-trees that are first
+bundled into an `application/x-tar` archive, and then compressed into an `application/gzip` archive). Using either of
+these two types is respectively incorrect or insufficient information to properly treat and extract the contained data.
 
-To mitigate this problem, mmmfs *types* can be nested. This is denoted in mmmfs *type* strings using the `->` symbol, e.g. the mmmfs-types
-`application/gzip -> application/tar -> dirtree` and `URL -> image/jpeg` describe a tar-gz-compressed directory tree and the URL linking to a JPEG-picture respectively.
+To mitigate this problem, mmmfs *types* can be nested. This is denoted in mmmfs *type* strings using the `->` symbol,
+e.g. the mmmfs *types* `application/gzip -> application/tar -> dirtree` and `URL -> image/jpeg` describe a
+tar-gz-compressed directory tree and the URL linking to a JPEG-encoded picture respectively.
 
 Depending on the outer type this nesting can mean different things:
 for URLs the nested type is expected to be found after fetching the URL with HTTP,
 compression formats are expected to contain contents of the nested types,
 and executable formats are expected to output data of the nested type.
 
-It is a lot more important to be able to accurately describe the type of a *facet* in mmmfs than in mainstream operating systems,
-because while in the latter types are mostly used only associate an application that will then prompt the user about further steps,
-mmmfs uses the *type* to automatically find one or more programs to execute to convert or transform the data stored in a *facet*
-into the *type* required by the application.
+It is a lot more important to be able to accurately describe the type of a *facet* in mmmfs than in mainstream operating
+systems, because while in the latter types are mostly used only associate an application that will then prompt the user
+for further steps if necessary, mmmfs uses the *type* to automatically find one or more programs to execute, in order to
+convert or transform the data stored in a *facet* into the *type* required in the context where it was requested.
 
-This process of *type coercion* uses a database of known *converts*, that can be applied to data.
-Every *convert* consists of a description of the input *types* that it can accept, the output *type* it would produce for a given input type,
-as well as the code for actually converting a given piece of data.
-Simple *converts* may simply consist of a fixed in and output type,
-such as for example this *convert* for rendering Markdown-encoded text to a HTML hypertext fragment:
+This process of *type coercion* uses a database of known *converts* that can be applied to data. Every *convert*
+consists of a description of the input *types* that it can accept, the output *type* it would produce for a given input
+type, as well as the code for actually converting a given piece of data. Simple *converts* may simply consist of a fixed
+in and output type, such as for example this *convert* for rendering Markdown-encoded text to a HTML hypertext fragment:
 
     {
       inp: 'text/markdown'
@@ -129,8 +136,8 @@ Other *converts* on the other hand may accept a wide range of input types:
 This convert uses a Lua Pattern to specify that it can accept an URL to any type of image,
 and convert it to an HTML fragment.
 
-By using the pattern substitution syntax provided by the Lua `string.gsub` function,
-converts can also make the type they return depend on the input type, as is required often when nested types are unpacked:
+By using the pattern substitution syntax provided by the Lua `string.gsub` function, converts can also make the type
+they return depend on the input type, as is required often when nested types are unpacked:
 
     {
       inp: 'application/gzip -> (.*)'
@@ -139,11 +146,11 @@ converts can also make the type they return depend on the input type, as is requ
         -- implementation stripped for brevity
     }
 
-This *convert* accepts an `application/gzip` *type* wrapping any other *type*, and captures that nested type in a pattern group.
-It then uses the substituion syntax to specify that nested type as the output of the conversion.
+This *convert* accepts an `application/gzip` *type* wrapping any other *type*, and captures that nested type in a
+pattern group. It then uses the substituion syntax to specify that nested type as the output of the conversion.
 For an input *type* of `application/gzip -> image/png` this *convert* would therefore generate the type `image/png`. 
 
-To further demonstrate the flexibility using this approach, consider this last example:
+This last example further demonstrates the flexibility of this approach:
 
     {
       inp: 'text/moonscript -> (.*)'
@@ -154,30 +161,31 @@ To further demonstrate the flexibility using this approach, consider this last e
 This *convert* transpiles MoonScript source-code into Lua source-code, while keeping the nested type
 (in this case the result expected when executing either script) the same.
 
-In addition to the attributes shown above, every *convert* is also rated with a *cost* value.
-The cost value is meant to roughly estimate both the cost (in terms of computing power) of the conversion,
-as well as the accuracy or immediacy of the conversion.
-For example, resizing an image to a lower size should have a high cost, because the process is computationally expensive,
-but also because a smaller image represents the original image to a lesser degree.
-Similarily, an URL to a piece of content is a less immediate representation than the content itself,
-so the cost of a *convert* that simply generates the URL to a piece of data should be high even if the process is very cheap to compute.
-
-Cost is defined in this way to make sure that the result of a type-coercion operation reflects the content that was present as accurately as possible.
-It is also important to prevent some nonsensical results from occuring, such as displaying a link to content instead of the content itself because
-the link requires less steps to create than completely converting the content does.
-
-Type coercion is implemented using a general pathfinding algorithm, similar to A\*.
-First, the set of given *types* is found by selecting all *facets* of the *fileder* that match the *name* given in the query.
-The set of given *types* is marked in green in the following example graph.
-
-From there the algorithm recursively checks whether it can reach other types by applying all matching *converts* to the type
-that is cheapest to reach, excluding any types that have already been exhaustively-searched in this way.
-All types it finds, that have not yet been inserted into the set of given types are then added to the set,
-so that they may be searched as well.
-
-The algorithm doesn't stop immediately after reaching a type from the result set,
-it continues search until it either completely exhausts the result space,
-or until all non-exhaustively searched paths are already higher than the maximum allowed path.
-This ensures that the optimal path is found, even if a more expensive path is found more quickly initially.
-
-<mmm-embed path="type_coercion_graph">excerpt of the graph of conversion paths from two starting facets to mmm/dom</mmm-embed>
+In addition to the attributes shown above, every *convert* is also rated with a *cost* value. The cost value is meant to
+roughly estimate both the cost (in terms of computing power) of the conversion, as well as the accuracy or immediacy of
+the conversion. For example, resizing an image to a lower size should have a high cost, because the process is
+computationally expensive, but also because a smaller image represents the original image to a lesser degree.
+Similarily, an URL to a piece of content is a less immediate representation than the content itself, so the cost of a
+*convert* that simply generates the URL to a piece of data should be high even if the process is very cheap to compute.
+
+Cost is defined in this way to make sure that the result of a type-coercion operation reflects the content that was
+present as accurately as possible. It is also important to prevent some nonsensical results from occuring, such as
+displaying a link to content instead of the content itself because the link is cheaper to create than completely
+converting the content does.
+
+Type coercion is implemented using a general pathfinding algorithm, based on *Dijkstra's Algorithm*<mmm-embed
+path="../references/dijkstra" wrap="sidenote"></mmm-embed>. First, the set of given *types* is found by selecting all
+*facets* of the *fileder* that match the *name* given in the query. The set of given *types* is marked in green in the
+following example graph.
+From there the algorithm recursively checks whether it can reach other *types* by applying all matching *converts* to
+the *type* that is the cheapest to reach currently, excluding any *types* that have already been exhaustively-searched
+in this way. All *types* found that have not yet been inserted into the set of given *types* are then added to the
+set, so that they may be searched as well.
+
+The algorithm doesn't stop immediately after reaching a *type* from the result set, it continues search until it either
+completely exhausts the result space, or until all non-exhaustively searched paths already have costs higher than the
+allowed maximum. This ensures that the optimal path is found, even if a more expensive path is found more quickly
+initially.
+
+<mmm-embed path="type_coercion_graph">excerpt of the graph of conversion paths from two starting facets to mmm/dom
+</mmm-embed>
diff --git a/root/articles/mmmfs/motivation/$order b/root/articles/mmmfs/motivation/$order
index c327490..accfc0b 100644
--- a/root/articles/mmmfs/motivation/$order
+++ b/root/articles/mmmfs/motivation/$order
@@ -1 +1,2 @@
+app-types
 creative
diff --git a/root/articles/mmmfs/motivation/app-types/text$markdown.md b/root/articles/mmmfs/motivation/app-types/text$markdown.md
new file mode 100644
index 0000000..aac79d7
--- /dev/null
+++ b/root/articles/mmmfs/motivation/app-types/text$markdown.md
@@ -0,0 +1,3 @@
+While there can be a distinction between *Native Applications* and *Web Applications* or *Cloud Services*, the following
+arguments apply to all different technicalal implementations of this same concept. The problems associated
+specifically with Web- and Cloud-based application models will be discussed separately below.
diff --git a/root/articles/mmmfs/motivation/text$markdown+sidenotes.md b/root/articles/mmmfs/motivation/text$markdown+sidenotes.md
index f0c2e6c..ab18726 100644
--- a/root/articles/mmmfs/motivation/text$markdown+sidenotes.md
+++ b/root/articles/mmmfs/motivation/text$markdown+sidenotes.md
@@ -7,37 +7,29 @@ application-centric design
 The majority of users interact with modern computing systems in the form of smartphones, laptops or desktop PCs,
 using the mainstream operating systems Apple iOS and Mac OS X, Microsoft Windows or Android.
 
+<mmm-embed path="app-types" wrap="marginnote"></mmm-embed>
 All of these operating systems share the concept of *Applications* (or *Apps*) as one of the core pieces of their
 interaction model. Functionality and capabilities of the digital devices are bundled in, marketed, sold and distributed
-as applications.
+as applications. This focus on applications as the primary unit of systems can be seen as the root cause of multiple problems.
 
-<!-- native vs other vs new ?? -->
-<!-- limitations not mentioned yet -->
-In addition, a lot of functionality is nowadays delivered in the form of *Web Apps* or *Cloud Services*, which share the 
-limitations of native applications in addition to more specific issues that will be discussed in a separate section
-below.
-
-This focus on applications as the primary unit of systems can be seen as the root cause of multiple problems.
-
-<!--                                                                           rephrase vvv -->
-For one, since applications are the products companies produce, and software represents a market of users,
+For one, since applications are produced by private companies on the software market,
 developers compete on features integrated into their applications. To stay relevant, monlithic software or software
 suites tend to accrete features rather then modularise and delegate to other software<mmm-embed wrap="sidenote"
 path="../references/appliances"></mmm-embed>. This makes many software packages more complex and unintuitive than
 they need to be, and also cripples interoperability between applications and data formats.
 
-Because applications are incentivised to keep customers, they make use of network effects to keep customers locked-in.
-This often means re-implementing services and functionality that is already available to users,
+Because (private) software developers are incentivised to keep customers, they make use of network effects to keep
+customers locked-in. This often means re-implementing services and functionality that is already available to users,
 and integrating it directly in other applications or as a new product by the same organisation.
-While this strategy helps big software companies retain customers, it harms the users, who have to navigate a complex
+While this strategy helps big software companies retain customers, it harms users, who have to navigate a complex
 landscape of multiple incompatible, overlapping and competing software ecosystems.
 Data of the same kind, a rich-text document for example, can be shared easily within the software systems of a certain
-manufacturer, and with other users of the same, but sharing with users of a competing system, even if it has almost the
+manufacturer and with other users of the same, but sharing with users of a competing system, even if it has almost the
 exact same capabilities, can often be problematic.
 
-Another issue is that due to the technical challenges of building tools in this system, applications are designed and
+Another issue is that due to the technical challenges of development in the this paradigm, applications are designed and
 developed by experts in application development, rather than experts in the domain of the tool. While developers may
-solicit feedback, advice and ideas from domain experts, communication is a barrier. Additionally, domain experts are
+solicit feedback, advice, and ideas from domain experts, communication is a barrier. Additionally, domain experts are
 generally unfamiliar with the technical possibilities, and may therefore not be able to express feedback that would lead
 to more significant advances.
 <mmm-embed path="creative" wrap="marginnote"></mmm-embed>
@@ -48,7 +40,7 @@ The application-centric computing metaphor treats applications as black boxes, a
 customize or modify the behaviour of apps, intentionally obscuring the inner-workings of applications and
 completely cutting users off from this type of ownership over their technology. While the trend seems to be to further
 hide the way desktop operating systems work<mmm-embed path="../references/osx-files" wrap="sidenote"></mmm-embed>,
-mobile systems like Apple's *iOS* already started out as such so-called *walled gardens*.
+mobile systems like Apple's *iOS* already started out as such *walled gardens*.
 
 cloud computing
 ---------------
@@ -68,15 +60,15 @@ continue servicing a customer, the users data may be irrecoverably lost (or acce
 consequences<mmm-embed path="../references/adobe" wrap="sidenote"></mmm-embed>, especially for professional users, for
 whom an inability to access their tools or their cloud-stored data can pose an existential threat.
 
-inert data (formats)
---------------------
+inert data (and data formats)
+-----------------------------
 
 Cragg coins the term "inert data"<mmm-embed path="../references/super-powers" wrap="sidenote"></mmm-embed> for the data
-created, and left behind, by apps and applications in the computing model that is currently prevalent: Most data today
+created and left behind by apps and applications in the computing model that is currently prevalent: Most data today
 is either intrinsically linked to one specific application, that controls and limits access to the actual information,
-or even worse, stored in the cloud where users have no direct access at all and depend soley on online tools that
-require a stable network connection and a modern browser, and that could be modified, removed or otherwise negatively
-impacted at any moment.
+or, even worse, stored in the cloud where users have no direct access at all. In the latter case users depend soley on
+online tools that require a stable network connection and a modern browser and could be modified, removed, or otherwise
+negatively impacted at any moment.
 
 Aside from being inaccesible to users, the resulting complex proprietary formats are also opaque and useless to other
 applications and the operating system, which often is a huge missed opportunity: 
@@ -98,9 +90,9 @@ individual file stands for itself. Grouping of files in folders is allowed as a
 applications only ever concern themselves with a single file at a time, independent of the context the file is stored in
 in the filesystem.
 
-Data rarely really fits this metaphora of individual files very well, and even when it does, it is rarely exposed to
+Data rarely really fits this concept of individual files very well, and even when it does, it is rarely exposed to
 the user that way: The 'Contacts' app on a mobile phone for example does not store each contacts's information in a
-separate 'file' (as the metaphora may suggest initially), but rather keeps all information in a single database file,
+separate 'file' (as the word may suggest initially), but rather keeps all information in a single database file,
 which is hidden away from the user. Consequently, access to the information contained in the database is only enabled
 through the contacts application's graphical interface, and not through other applications that generically operate on
 files.
@@ -111,21 +103,25 @@ brainstorm, many might be tempted to open an application like *Microsoft Word* o
 document there. Both *Photoshop* files and *Word* documents are capable of containing texts and images, but when such
 content is copied into them from external sources, such as other files on the same computer, or quotes and links from
 the internet, these relationships are irrevocably lost. As illustrated above, additionally, it becomes a lot harder to
-edit the content once it is aggregated as well. To choose an application for this task is a trade-off, because in
-applications primarily designed for word processing, arranging content visually is harder and image editing and video
-embedding options are limited, while tools better suited to these tasks lack nuance when working with text.
-
-Rather than face this dilemma, a more sensible system could leave the task of positioning and aggregating content of
-different types to one software component, while multiple different software components can be responsible for editing
-the individual pieces of content, so that the most appropriate one can be chosen for each element.
+edit the content once it is aggregated. To choose an application for this task is a hard trade-off to make, because in
+applications primarily designed for word processing, arranging content visually is hard to do, and image editing and
+video embedding options are limited, while tools better suited to these tasks lack nuance when working with text.
+
+To avoid facing this dilemma, a more sensible system could leave the task of positioning and aggregating content of
+different types to one software component, while multiple different software components could be responsible for editing
+the individual pieces of content, so that the most appropriate one can be chosen for each element. While creating the
+technological interface between these components is certainly a challenge, the resulting system would greatly benefit
+from the exponentially-growing capabilties resulting from the modular reuse of components across many contexts: A rich
+text editor component could be used for example not just in a mixed media collection as proposed above, but also for
+an email editor or the input fields in a browser.
 
 <div style="height: 2rem;"></div>
 
-To summarize, for various reasons, the metaphors and interfaces of computing interfaces today prevent users from deeply
-understanding the software they use and the data they own, from customizing and improving their experience and
+To summarize, for various reasons, the metaphors and driving concepts of computing interfaces today prevent users from
+deeply understanding the software they use and the data they own, from customizing and improving their experience and
 interactions, and from properly owning, contextualising and connecting their data.
 
-Interestingly, these deficits do not appear throughout the history of todays computing systems, but are based in rather
+Interestingly, these deficits do not appear throughout the history of today's computing systems, but are based in rather
 recent developments in the field. In fact the most influental systems in the past aspired to the polar opposites, as i
 will show in the next section.
 
diff --git a/root/articles/mmmfs/print: text$moonscript -> fn -> mmm$dom.moon b/root/articles/mmmfs/print: text$moonscript -> fn -> mmm$dom.moon
index 0dac590..615075a 100644
--- a/root/articles/mmmfs/print: text$moonscript -> fn -> mmm$dom.moon
+++ b/root/articles/mmmfs/print: text$moonscript -> fn -> mmm$dom.moon
@@ -4,48 +4,23 @@
 -- resolves to a value of type mmm/dom
 =>
   html = require 'mmm.dom'
-  import article, h1, h2, h3, section, p, div, a, sup, ol, li, span, code, pre, br from html
+  import article, h1, p, div from html
   import moon from (require 'mmm.highlighting').languages
 
-  article with _this = class: 'sidenote-container', style: { 'max-width': '640px', 'line-height': '1.5' }
+  article with _this = class: 'sidenote-container spacious', style: { 'max-width': '640px', 'line-height': '1.5' }
     append = (a) -> table.insert _this, a
 
-    footnote, getnotes = do
-      local *
-      notes = {}
+    append div {
+      h1 'Empowered End-User Computing', style: { 'margin-bottom': 0 }
+      p {
+        style:
+          'margin-top': 0
+          'padding-bottom': '0.2em'
+          'border-bottom': '1px solid black'
 
-      id = (i) -> "footnote-#{i}"
-
-      footnote = (stuff) ->
-        i = #notes + 1
-        notes[i] = stuff
-        sup a "[#{i}]", style: { 'text-decoration': 'none' }, href: '#' .. id i
-
-      footnote, ->
-        args = for i, note in ipairs notes
-          li (span (tostring i), id: id i), ': ', note
-        notes = {}
-        table.insert args, style: { 'list-style': 'none', 'font-size': '0.8em' }
-        ol table.unpack args
-
-    append h1 'Empowered End-User Computing', style: { 'margin-bottom': 0 }
-    append p "A Historical Investigation and Development of a File-System-Based Environment", style: { 'margin-top': 0, 'padding-bottom': '0.2em', 'border-bottom': '1px solid black' }
-
-    -- render a preview block
-    do_section = (child) ->
-      -- get 'title' as 'text/plain' (error if no value or conversion possible)
-      title = (child\get 'title: text/plain') or child\gett 'name: alpha'
-
-      -- get 'preview' as a DOM description (nil if no value or conversion possible)
-      content = (child\get 'preview: mmm/dom') or child\get 'mmm/dom'
-
-      section {
-        h3 title, style: { margin: 0, cursor: 'pointer' }, onclick: -> BROWSER\navigate child.path
-        content or span '(no renderable content)', style: { color: 'red' },
+        "A Historical Investigation and Development of a File-System-Based Environment"
       }
+    }
 
     for child in *@children
       append (child\get 'print: mmm/dom') or (child\gett 'mmm/dom')
-      -- do_section child
-
-    append getnotes!
diff --git a/root/articles/mmmfs/references/$order b/root/articles/mmmfs/references/$order
index 01b0c04..1e250b7 100644
--- a/root/articles/mmmfs/references/$order
+++ b/root/articles/mmmfs/references/$order
@@ -16,3 +16,5 @@ acm-dl
 aspect-ratios
 alternatives-to-trees
 transclusion
+mime-types
+dijkstra
diff --git a/root/articles/mmmfs/references/dijkstra/text$bibtex b/root/articles/mmmfs/references/dijkstra/text$bibtex
new file mode 100644
index 0000000..c38a470
--- /dev/null
+++ b/root/articles/mmmfs/references/dijkstra/text$bibtex
@@ -0,0 +1,17 @@
+@article{10.1007/BF01386390,
+  author = {Dijkstra, Edsger W.},
+  title = {A Note on Two Problems in Connexion with Graphs},
+  year = {1959},
+  issue_date = {December 1959},
+  publisher = {Springer-Verlag},
+  address = {Berlin, Heidelberg},
+  volume = {1},
+  number = {1},
+  issn = {0029-599X},
+  url = {https://doi.org/10.1007/BF01386390},
+  doi = {10.1007/BF01386390},
+  journal = {Numer. Math.},
+  month = dec,
+  pages = {269–271},
+  numpages = {3}
+}
diff --git a/root/articles/mmmfs/references/mime-types/text$bibtex b/root/articles/mmmfs/references/mime-types/text$bibtex
new file mode 100644
index 0000000..c49b553
--- /dev/null
+++ b/root/articles/mmmfs/references/mime-types/text$bibtex
@@ -0,0 +1,14 @@
+@article{rfc6838,
+  series = {Request for Comments},
+  number = 6838,
+  howpublished = {RFC 6838},
+  publisher = {Internet Engineering Task Force},
+  doi =  {10.17487/RFC6838},
+  url =  {https://tools.ietf.org/html/rfc6838},
+  author = {Freed, Ned and Klensin, John C. and Hansen, Tony},
+  title =  {Media Type Specifications and Registration Procedures},
+  pagetotal = 32,
+  year =  2013,
+  month =  jan,
+  abstract = {This document defines procedures for the specification and registration of media types for use in HTTP, MIME, and other Internet protocols. This memo documents an Internet Best Current Practice.},
+}
diff --git a/root/articles/mmmfs/statement-of-originality/text$html+frag.html b/root/articles/mmmfs/statement-of-originality/text$html+frag.html
new file mode 100644
index 0000000..d5fd76f
--- /dev/null
+++ b/root/articles/mmmfs/statement-of-originality/text$html+frag.html
@@ -0,0 +1,13 @@
+<div class="print-only print-ownpage" style="margin: 4cm 0 0;">
+<h1>Statement of Originality</h1>
+<p style="margin-top: 5cm">
+This is to certify that the content of this project, documentation and thesis is my own work. It 
+has not been submitted for any other degree or other purposes. I certify that the intellectual 
+content of my submission is the product of my own work and that all the assistance received in 
+preparing it as well as all sources used have been properly acknowledged.
+</p>
+
+<div style="border-top: 1px solid #000; width: 7cm; margin-top: 3cm;">
+Sol Bekic
+</div>
+</div>
diff --git a/root/articles/mmmfs/text$moonscript -> fn -> mmm$dom.moon b/root/articles/mmmfs/text$moonscript -> fn -> mmm$dom.moon
index 1939042..89c9a7d 100644
--- a/root/articles/mmmfs/text$moonscript -> fn -> mmm$dom.moon
+++ b/root/articles/mmmfs/text$moonscript -> fn -> mmm$dom.moon
@@ -4,48 +4,24 @@
 -- resolves to a value of type mmm/dom
 =>
   html = require 'mmm.dom'
-  import article, h1, h2, h3, section, p, div, a, sup, ol, li, span, code, pre, br from html
+  import article, h1, p, div from html
   import moon from (require 'mmm.highlighting').languages
 
-  article with _this = class: 'sidenote-container', style: { 'max-width': '640px', 'line-height': '1.5' }
+  article with _this = class: 'sidenote-container spacious', style: { 'max-width': '640px', 'line-height': '1.5' }
     append = (a) -> table.insert _this, a
 
-    footnote, getnotes = do
-      local *
-      notes = {}
+    append div {
+      class: 'screen-only'
+      h1 'Empowered End-User Computing', style: { 'margin-bottom': 0 }
+      p {
+        style:
+          'margin-top': 0
+          'padding-bottom': '0.2em'
+          'border-bottom': '1px solid black'
 
-      id = (i) -> "footnote-#{i}"
-
-      footnote = (stuff) ->
-        i = #notes + 1
-        notes[i] = stuff
-        sup a "[#{i}]", style: { 'text-decoration': 'none' }, href: '#' .. id i
-
-      footnote, ->
-        args = for i, note in ipairs notes
-          li (span (tostring i), id: id i), ': ', note
-        notes = {}
-        table.insert args, style: { 'list-style': 'none', 'font-size': '0.8em' }
-        ol table.unpack args
-
-    append h1 'Empowered End-User Computing', style: { 'margin-bottom': 0 }
-    append p "A Historical Investigation and Development of a File-System-Based Environment", style: { 'margin-top': 0, 'padding-bottom': '0.2em', 'border-bottom': '1px solid black' }
-
-    -- render a preview block
-    do_section = (child) ->
-      -- get 'title' as 'text/plain' (error if no value or conversion possible)
-      title = (child\get 'title: text/plain') or child\gett 'name: alpha'
-
-      -- get 'preview' as a DOM description (nil if no value or conversion possible)
-      content = (child\get 'preview: mmm/dom') or child\get 'mmm/dom'
-
-      section {
-        h3 title, style: { margin: 0, cursor: 'pointer' }, onclick: -> BROWSER\navigate child.path
-        content or span '(no renderable content)', style: { color: 'red' },
+        "A Historical Investigation and Development of a File-System-Based Environment"
       }
+    }
 
     for child in *@children
       append child\gett 'mmm/dom'
-      -- do_section child
-
-    append getnotes!
diff --git a/root/articles/mmmfs/title/text$html+frag.html b/root/articles/mmmfs/title/text$html+frag.html
new file mode 100644
index 0000000..1b0bf03
--- /dev/null
+++ b/root/articles/mmmfs/title/text$html+frag.html
@@ -0,0 +1,21 @@
+<div class="print-only print-ownpage" style="font-size: 1.5rem; width: calc(100% + var(--sidenote-width))">
+  <div style="font-size: 2rem; margin-top: 4cm">
+    <h1>Empowered End-User Computing</h1>
+    <span>A Historical Investigation and Development of a File-System-Based Environment</span>
+  </div>
+  <div style="width: 14cm; margin: 4cm auto 0">
+    <p>by</p>
+    <p>
+      Sol Bekic<br />
+      Student ID 11114279<br />
+      sol.bekic+ba@s-ol.nu
+    </p>
+    <p>
+      written in the Winter Term 2019/20<br />
+      for BA Digital Games<br />
+      at Cologne Game Lab / TH Köln
+    </p>
+    <p>supervised by Prof. Dr. Gundolf S. Freyermuth</p>
+    <p>submitted on 2020-01-07</p>
+  </div>
+</div>