I am employed full time as a functional programmer by a company that design tools that are used by quants to analyze stocks, bonds, and portfolios, and I get to work on the open source functional programming libraries that we use.
I mostly work in Scala and Haskell, but in the past I have also done paid consulting in Erlang.
How did I get here?
I abandoned college to do programming at Ford and to run a very early internet startup out of my basement back in 94. I transitioned to working at the regional internet service provider that was hosting me, doing misc. systems programming, and eventually transitioned to CTO. Along the way I became involved in the demo scene, and licensed technology to game companies.
I also spent a lot of my spare time obsessing about how to design better programming languages, but sadly I lacked knowledge of the state of the art in that area. I became heavily interested in concurrency and proving the correctness of code, unfortunately, my world-view was somewhat distorted, and I only thought of the latter through the lens of Hoare triples and separation logic.
By the time the dot-com crash hit, we were a nationwide DSL provider and my resume was too mismatched to find work, between the lack of formal education and the glut of senior management experience.
Licking my wounds I went back to college and binged through a bunch of degrees as quickly as I could. While I was working on my second Masters I discovered Haskell, and I had more or less a religious conversion experience. Here was a language that had solutions to many of the things that I had been trying to express in my pet language projects backed by a much more sound theory than any of the ad hoc solutions I had come up with to date.
I binged obsessively through Types and Programming Languages, everything I could find on substructural logic and pure type systems, and read every paper I could find on functional programming for the better part of a year.
Because it is relevant to the conclusion, I'll sermonize a bit. Along the way I spent a lot of time obsessing about how category theory and functional programming interact. This has led to a lot of interesting and surprisingly practical applications for Kan extensions, the Yoneda lemma, etc. But ultimately, what I like about functional programming is that with fine grained control over side-effects, parallelism and concurrency are vastly easier to reason about. I like to go as far out into theory as I can drag kicking and screaming back into practice. Object-oriented code sprinkles synchronization points across your entire codebase, due to the existence of objects that have mutable state. Pure functional code on the other hand provides far fewer choke points.
After that, the economy recovered, and my resume was no longer so mismatched. I moved to the coast to do defense contracting for a few years, and started doing consulting on massively-distributed systems and functional programming.
My current position came about when a couple of folks from ClariFi came out to see a talk that I gave at the Boston Haskell user group on how one can use monoids in purely functional code to increase opportunities for parallelism.
They went and implemented that solution, and brought me in to do consulting, and later offered me enough to lure me away from the defense contracting world and to convince me to come on board full time.
Now, I spend a lot of time on the clock working on scalaz, the main scala functional programming library. It adapts many Haskell ideas such as monads, etc. to Scala, but more interestingly, it has no real legacy code base and pile of books to support, so it has been able to fix many of the historical accidents and warts of the Haskell Prelude.
Others built scalaz before I even learned scala, but there is a lot of overlap between the communities, and it was based fairly heavily on work that I did in Haskell, so it has been a very smooth transition.
So ultimately, I get paid to work on a mishmash of open- and close- sourced code, much of which was based on my own choice of abstractions.
There are worse jobs.
TL;DR I got here through a mixture of real world experience, contacts, academic credibility, community involvement, a lot of open source software development, and consulting.