stevengharms.com

Sententiae viri ex temporibus duobus

Pivoting: In Startups and Programming

Mike Maples' recent discussion on startups was my morning listening as I churned through weekend email stack and I came away with the following notes.

  • Maples chases Thunder Lizards
    • Godzillas
    • They start from atomic eggs
    • Disrupt their ecosystem (fishing boat)
      • Disrupt the embeddeds (storm into Tokyo)
      • Devour the embeddeds (eat the power lines and the trains)
      • Rare: Cisco, Intel
      • They take all the Oxygen out of the room, high tech has little room for also-rans
        • 1 takes the glory

        • 2 takes some pittance

          #3 == who?

  • The business of a startup is to validate ab usiness model
    • It must present how their business creates, stores, and delivers value
    • You should do something like the above that brings in money more than you spend it
    • Upon finding a successful one of these, maximize the delta (duh)
  • Pivoting
    • You must be able to throw away a really good business model
      * iPhone games
          * Charge $10.00! - making money!
          * Market pushes price to $2.00 - making very little money
          * Entrenched players, low barrier to entry
          * BAIL BAIL BAIL BAIL!  You should BAIL
            * You're spending time trying to make $2.00 grow, not finding that great $10/unit model!
            * This is hard cf. Cortez and his ships
      * Odeo
          * People will want to do audio blogs, podcasts
          * Great!
          * AAPL enters.  Crap.
          * Hey I added this `twttr` feature <- that was a winner
      
  • Great startups CAN and DO pivot and this is their edge against a Thunder Lizard. By maximizing on a great pivot they can become a Thunder Lizard!

This thing really inspired me. You see, I had an idea after Silicon Valley Code Camp I thought I would create a tool that allows one to write Markdown style text as an internal Ruby DSL but that would add the ability to add Semantic payload to the text easily.

It started off on a bad foot, a footing that should have scared me off. The way one formats a heading in Markdown is by using the ‘#’ character. One ‘#’ means an ‘h1’ heading, ‘##’ means 2, etc. But ‘#’ in Ruby means a comment.

So as an internal DSL I was going to have to tell Ruby to ignore its nature that ‘#’ doesn’t mean what it thinks it means and that etc.

This is madness.

I looked back at the Markdown documentation and found an exculpatory clause in Markdown’s documentation:

While Markdown’s syntax has been influenced by several existing text-to-HTML filters, the single biggest source of inspiration for Markdown’s syntax is the format of plain text email.

Wait a second, if you’re writing a plain text email, you want to set things off visually. You want the plain text to try to imitate the power of newsprint or a memo.

# THE HISTORY OF THE WORLD #


## Volume 1:  The Greeks ##
1.  They invented philosophy
   1. Thales
   1. Anaximander
   1. Anaximenes
1.  The Sophists

* Greek Cuisine
  * Olive oil
  * Feta
------------------------------------------------------------------------------

## Volume 2:  The Romans ##

* amare
* dicere
  * irregular imperative:  dic
  * dicite

This is not a format for which adding rich metadata is ideal, it’s a format which looks great in plain text OR which can be converted to more rich HTML. Only a fool would try to coerce those non-fitting bits together.

This guy.

Looking at the other markup language Textile, it’s obvious that it’s a language meant for structure. How do you make an

in Textile? You type h1. This is obviously a language for people who are thinking about HTML as the goal and are using a simplified markup language for producing that output.

Unsurprisingly, this works much better. This was just a sketch a typed up between San Francisco and Palo Alto on the train:

    def html(&b;)
      puts "No usable input" if b.nil?
      puts ""
      yield
      puts ""
    end

    def h1(t)
      puts "

#{t}

“ end

    def h2(t)
      puts "

#{t}

“ end

    def p(*args,&b;)
      print "

“ if args[0].nil? puts _reformatter(yield) else args[0] end puts ”

“ end

    def _reformatter(t)
      t.gsub! "\n", ' '
      t.gsub! '  ', "\n"
      # More reformatting goes here...
      t
    end

    html do 
      h1 "This is an HTML document"
      h2 "This is a topic"
       p do
          "There is no argument here.
          I encourage all of you to be *bold*
          and _emphatic_ and to accept your
          -errors- as mere +moments+ leading to
          the full culmination of self."
         end
    end

Running this nets:

    <html>
    <h1>This is an HTML document</h1>
    <h1>This is a topic</h1>
    <p>There is no argument here.


     I encourage all of you to be *bold*


     and _emphatic_ and to accept your


     -errors- as mere +moments+ leading to


     the full culmination of self.
    </p>
    </html>

So, Mr. Maples, you convinced me, sometimes you have to ditch that loser idea, drop that pair of pocket queens and pivot.

Comments