now let's take another step forward

# now let's take another step forward

now that we've got something straightforward
put into place, let's see if we can stretch a bit.

first, though, let's do the error-correction thing.

## table of contents


## bowerbird made a mistake, and apologizes

gerald said:

> There's no dependency on Ruby or Ruby on Rails.
> It's a static (server-less) single HTML page (w/ JS and CSS)

thanks for correcting my error in that regard.


gerald said:

> I guess it's my error -- will remove the
> real world case study (that mentions Ruby on Rails
> and might, thus, lead you to think you need Ruby

no, it was clearly my error, not yours, and i apologize.

(Continue reading)

Gerald Bauer | 29 Aug 17:13 2014

New GitHub Org - writekit - Markdown Tools, Scripts, Themes 'n' More


  FYI: I've moved markdown-note - the single-page static
(server-less/offline) markdown side-by-side editor -  to its own
GitHub org, that is, writekit [1]

   I've also rewritten the readme [2] (no more references to Ruby or
Ruby on Rails) and included the missing installation steps.

   And last but not least I started on new modular version; new modules include:

    - markdown.lib.js
    - markdown.api.js
    - markdown.themes
    - markdown.note.starter (An even simpler starter version;

  Have a great weekend. Cheers.

[1] github.com/writekit
[2] github.com/writekit/markdown.note

what i meant by "simple"

# what i meant by "simple"

## table of contents

what i meant by "simple"
table of contents
about the message i posted
what gerald said
what john said
what i mean by "simple"
my general responses
my code was also less than perfect
and now no framework required
what this code facilitates
on the matter of doing sync
determining the line the cursor is on

## about the message i posted

first let's look at what people said about my post.

### what gerald said

gerald said:

> I published a simple single static HTML page
> side-by-side markdown editor about a year ago.

> http://geraldb.github.io/markdown-note/note.html

(Continue reading)


simple sample side-by-side setup

# simple sample side-by-side setup

there are so many light-markup editing environments
out there these days that it takes a good deal of time
to evaluate which one might be right for you.
and even after you've done that, you might
wish some of its features were slightly different.

the good news is that it's relatively easy to set up
a side-by-side .html page. from there, you can
customize the environment to your own preferences.

here's some sample code that creates such a split-screen set-up:

> http://zenmagiclove.com/misc/sssss/side-by-side.html

## the basic set-up

the left side is for editing the text,
and the right side is for displaying the .html.
as you would expect, as you edit,
the display on the right-side gets updated.

this is a simple javascript setup. it uses jquery at present;
you could make it independent, but the pageload burden
posed by jquery isn't really all that significant.

you'll notice that there are buttons along the top and bottom
of the page, which you can use for any functionality you might
want to incorporate. some of them are currently just
(Continue reading)

bowerbird | 18 Aug 21:31 2014

here are some opinions

here are some opinions; take 'em or leave 'em.

we might eventually have as many "standard"
editions of markdown as we now have flavors.
that should make things twice as fun as before.


any spec without an accompanying converter is
all talk and no action; the proof is in the pudding.


if you don't have a javascript conversion routine,
you do not have something that can be bundled
into an .html file, which is something you _need_.

and if you haven't ported your javascript converter,
to some other common language, you do not know
that it is robust enough for usage in the real world.


in this age of full-on markdown editing environments,
many open-source, a dingus is miserably insufficient.

>   dillinger -- https://github.com/joemccann/dillinger
>   stackedit -- https://github.com/benweet/stackedit
>   gfmarkdown -- http://jbt.github.io/markdown-editor
>   minimalist -- 
(Continue reading)

Andrei Fangli | 16 Aug 16:34 2014

Flexible Markdown Parser

I'm new around here this being my first post (if I did posted in a wrong meaner please point it out).
Since you guys are working on Markdown syntax & parsers I thought I should butt in and show off with a little piece of work that I have been working on.
Since I followed the interview with John Gruber and he stated that he wouldn't want to standardize Markdown and would rather keep the syntax description ambiguous so flavors of the language may emerge to suit the needs of the one(s) using Markdown. I realized that a parser with fixed syntax would not encourage these "flavors" at all. Nor encourage people to use it much (since my interpretation of Markdown is not universal). With that in mind I shifted from defining a rather "static" parser to a more flexible one.
The implementation (in Perl) offered by John Gruber relies heavily on regex which gave me an idea. I'm a C# developer therefore what I am working on targets .NET Framework and the idea that I got was to make parser that relies mostly on the object model of Regex offered by .NET. The current implementation is rather a prototype for a greater more powerful parser.
Now to make more sense of what I am talking about. I wrote the implementation of the parser in an abstract class delegating to subclasses what factories for node creation to use (Factory Method that returns a list of Strategies where the Strategy is object creation). There are two types of nodes: leaf and composite thus there are two Strategy interfaces.
The ILeafNodeFactory has a Pattern (Regex), a Name (to use when referencing factories from a composite one and a Create method which, obviously, creates the node given a regex Match).
The ICompositeNodeFactory has the same stuff as ILeafNodeFactory only that the Create method takes an extra parameter (a list of child nodes) and for a composite node factory you need to specify what factories are applicable to obtain child nodes (both leaf and composite work).
When you want your specific "flavor" of Markdown you simply subclass the MarkdownParser and implement the abstract methods. This means providing a list of ILeafNodeFactory, a list of ICompositeNodeFactory and the name of the factory to apply for the root node. For each node factory you need to provide a unique name and a pattern which identifies the sequence of text representing the node. For composite node factories you also need to provide a list of factory names to know what node factories to use when trying to identify a child node text sequence.
The factories are tested in the base class. E.g.: you reference a factory that does not exist, exception is thrown. Or your composite factory has MarkdownTextNode as children and in the applicable child node factories say that a factory which returns a MarkdownNode (base class of MarkdownTextNode) then an exception is thrown because there is no implicit conversion from MarkdownNode to MarkdownTextNode.
All these validations are done in the base class constructor (MarkdownParser) meaning that if you want to test your specification you only need to create an instance of it and see if it throws any exceptions.
Sadly I haven't got yet to properly testing the parser much (just a dummy test with 2 factories) or make a default implementation for the rules specified on John Gruber's site but I am looking forward to it. The project source code is hosted on BItBucket: <https://bitbucket.org/Andrei15193/markdownparser>.
I hope I wasn't too techy or lacky in details. Constructive comments and critics are welcomed! Thanks in advance. :)
Markdown-Discuss mailing list
Markdown-Discuss <at> six.pairlist.net
Peter Occil | 14 Aug 19:46 2014

Moving Markdown towards a standard syntax

I became interested in defining Markdown and made an earnest attempt at a
Markdown standard, or at least a less ambiguous syntax specification than 
the original.
The document is found at: <http://peteroupc.github.io/markdownsyntax/>.

Note that it's currently incomplete, but it should be enough for you to 
comment on it.  It defines a parsing algorithm that follows the behavior of 
the majority of Markdown implementations.
The Markdown comparer at <http://johnmacfarlane.net/babelmark2/> helped me 
determine common behavior.

The project page is <https://github.com/peteroupc/markdownsyntax>.

Michel Fortin | 21 Jul 17:08 2014

Talk about Markdown in The Talk Show

There's a short discussion about Markdown between Marco Arment and John Gruber in The Talk Show, episode
"88: 'Cat Pictures', With Marco Arment (Side 1)" starting at time 1:15:13. I don't have anything
particular to say about it, but it's probably the closest thing to an official response you can get on some
things that were discussed on this list so I felt it was worth a link:



Michel Fortin
michel.fortin <at> michelf.ca
Jeff McNeill | 12 Jul 02:27 2014

Bland Markdown / IETF initiative

Not sure if this will help with the IETF discussion, but there is this:


Jeff McNeill 
+66 (0)80 673 1438
Markdown-Discuss mailing list
Markdown-Discuss <at> six.pairlist.net
bowerbird | 12 Jul 00:50 2014

a good sign

another long thread. isn't that cute?


it's far too little _and_ much too late.
all of the horses have now escaped,
so it will do no good to close the gate.


i will take it as a good sign when the name
is intentionally, actively, and loudly rejected.

when a new name and an energized mission,
educated with a sense of the possibilities and
a full determination to avoid the old problems,
rises from a new community of engaged users,
committed to the creation of an entire toolchain
-- without any further delay, because, honestly,
we needed this _yesterday_ -- i will be happy,
because then light-markup can get on with it,
so we can all move on to more important stuff.

the kludge was fine for a while, but it has now
lived long past its prime, and needs to be killed.

frankly, if you don't know that we can do better,
get out of the way. just plain get out of the way.


on the other hand, it amuses me to think that
-- down the line, let's say in 15 years time --
the old people who "want to use what i know"
are insisting on markdown the way those same
people today are refusing to give up ms-word.

of course, i am also amused that some of you
seem to be showing the tendency even today!    :+)

have a pleasant weekend!

Jeff McNeill | 10 Jul 03:20 2014

Markdown as genericized

Markdown has become genericized (and was never registered or defended as intellectual property). See http://en.wikipedia.org/wiki/Generic_trademark

The idea that Gruber has to (or even ever would) sign off on anything is counter to his behavior and stated opinion on the matter. His historical involvement and contemporary non-involvement should not become an impediment or even an issue for markdown-related development.

Jeff McNeill 

Markdown-Discuss mailing list
Markdown-Discuss <at> six.pairlist.net