In Paul Graham's 2001 essay Beating The Averages, he convinces you that:
So, 14 years later, what's changed? Can writing your company's product with Lisp still be an advantage?
A huge difference between development today and in 2001 is the present abundance of high-quality open source libraries.
The rate of new open source code being written is at an all-time high. At the time of this writing, there are nearly 200k modules published on npm. One of them probably does what you need it to do. 14 years ago, the ratio of code-you-wrote to code-somebody-else-wrote was higher.
The # of published modules is a hockey stick for npm.
Common Lisp is as high-level and expressive as a programming language can be, but does that advantage outweigh frictionless access to a rich ecosystem of code written in the same language as your software?
In 2007, a new lisp arrived on Earth. Straight outta Rich Hickey's hammock, Clojure hit the scene as a modern lisp that embraced the JVM. Clojure was born with more libraries for you to use than Java (since you could seamlessly use any Java code in your Clojure program, plus any libraries written for Clojure).
Want to use Express? Once your eyes adjust to the parenthesis coming first, it feels like home:
(def express (js/require "express")) (defn beep! [req res] (.send res "boop")) (let [app (express)] (.get app "/" beep!) (.listen app 3000 (fn  (println "Server started on port 3000")))))
Clojure programming is fast, fun, and interactive. The functional programming / immutable data at the core of the language make it easy to reason about complex systems. All you have to do is get used to the parenthesis coming before the verb.
Clojure may be the best tool for writing software that's ever existed, but it's relatively unknown! Smells like opportunity.
In a big company, you can do what all the other big companies are doing. But a startup can't do what all the other startups do. I don't think a lot of people realize this, even in startups.
If you do everything the way the average startup does it, you should expect average performance. The problem here is, average performance means that you'll go out of business. The survival rate for startups is way less than fifty percent. So if you're running a startup, you had better be doing something odd. If not, you're in trouble.
As a startup, you need to set yourself apart. It's not enough to know that Clojure is simply the best language for writing your software. You need to know that Clojure is the best language for your software and none of your competitors are going to use it.
Are people using Clojure? It's barely in the top 20 most popular programming languages, ranked alongside programming stepchildren such as Visual Basic. That's exactly where we want it to be. There's a happy medium somewhere between "I wrote this lang and I'm the only one who uses it" and "Java."
There's a community from which to hire talented programmers, but it's a small enough community that a Google-figure could hire the whole set.
What important truth do very few people agree with you on?
-- Peter Thiel
Your business must be predicated on a secret. You'll probably need something more original about your company than the programming language you use, but more contrarian-truthfulness is always better than less.
I think of a company's ability to compete as an exponential function, and the sum of your secrets is your exponent.
In my opinion, Lisp, in the form of Clojure, adds more to your exponent than 14 years ago, or ever before.
Oh crap, I probably shouldn't have told you.
 open Beating The Averages, cmd-F blub
 The base is how hard you work / how persistent you are.
 The syntax highlighter on this blog doesn't support Clojure / Lisp! I'm not going to search for another one because it supports my conclusion. LOLCODE support? check. Clojure? nah, weird parens.