Lambda Island Turns One, The Story of a Rocky Ride

One year ago to date I launched Lambda Island, a service that offers high quality video tutorials on web development with Clojure and ClojureScript. It’s been quite a ride. In this post I want to look back at the past year, provide some insight into how this experience has been for me, and give you a glimpse of what the future has in store.

This story really starts in December 2015. After three years of doing contract work for Ticketsolve I decided it was time for a change. I have been self-employed for many years, but I knew that sooner or later I wanted to try my hand at selling a product, rather than selling my time.

In January and February I took some time for soul-searching, and recharging. I went to speak at RubyConf Australia, and got to hang out with some old friends around Australia and New Zealand. Once back in Berlin I got busy creating Lambda Island.

I decided to build the site from scratch. There are plenty of reasons why this isn’t the best idea, many would argue I’d be better off using an existing platform, but so far I haven’t regretted the choice. I felt it was important for my street cred to be running a Clojure app in production.

I did choose to make use of a handful of well chosen SaaS providers to do the heavy lifting. Chargebee does all the subscription management and invoicing, and I’m very happy with their service. EU VAT regulation is complex and a pain to implement, but they handle that swimmingly.

Payment is handled through Chargebee by Stripe, video hosting is done by Vimeo, emails are sent with Mailgun, drip campaigns go out with Sendwithus, and the whole thing runs on Upcloud’s virtual servers. Upcloud generously sponsored the last ClojureCup, and the credit we won there kept the servers up for almost a year.

I also had to figure out how to create screencasts. I had made some videos before, but there’s a big difference between just recording a live coding session, and actually creating a high quality screencast. With trial and error I managed to come up with a recording and editing workflow that worked for me, and I’ve been improving upon that ever since. I’ll leave the details of that for another post.

After figuring out some legal aspects and creating the first few videos I was finally ready to launch, and on 13 May 2016 I welcomed my first customers.

I would need about 700 subscribers to make what I was making before with contract work, but I was prepared to take a big pay cut. I figured with 200 customers I would make enough to live, or 300 to live modest but comfortably. If I could get about 30 new subscribers each month, then by the time my savings would run out I would be self-sufficient, all by the end of 2016.

Spoiler: that’s not quite what happened. In the past month I finally broke through the first 100, and it’s been a big struggle to stay afloat.

Here you see the number of activations (initial signups or people who cancelled earlier and the re-activated their subscription), and number of cancellations (a.k.a. “The Churn”), for each month.

It’s been quite a rollercoaster ride. It all started off well. Twenty-five people signed up in the first two weeks. Many of those are still happy customers today. June and July were slow, but in August things were starting to pick up, and all through fall I had ten to fifteen new members each month.

At that point I had been working long days and weekends for close to half a year. I started getting more migraines and tension headaches, I had been getting sick more and more often, and mentally I was not in a good place. At the same time my financial reserve was getting dangerously low.

Around September I knew I needed a break, but I also urgently needed to make some money. I started looking for freelance Clojure work, but that wasn’t that easy to come by, especially not remote or part-time. I ended up taking on a project for Mein Grundeinkommen, a non-profit working to supply people with basic income. The break would have to wait.

This brought some financial relief, but it did keep me busy for a while, so in October and November only two new videos came out. After that I found a gig teaching programming a few hours a week. Together with what was slowly starting to come in from Lambda Island I could already cover a good part of my costs.

At the same time I started making some life style changes. I made an effort to block the weekends and evenings for things unrelated to work. I cut my alcohol consumption way back. I wasn’t a big drinker before, but I found I was getting very sensitive to it, and just a few drinks would have me feeling sick and depressed for days. I started doing more sports, and made sure to get enough sleep. Since January I’ve been doing an hour of Alexander Technique once a week with a teacher, and for over a month now I’ve been meditating once a day with Headspace.

I still haven’t gotten the break that I needed, and I still get sick too easily, but I’m in a much better place than I was six months ago. I’m feeling productive again and optimistic for the future. I’ve learned some hard lessons from it all, and in that sense it’s been an important experience. I’ll also be taking two weeks of actual holiday this summer, one week with my family, and one week at the European Juggling Convention, which I’m sure will do me good.

So that’s where we are now. One year in. One hundred subscribers. Why hasn’t it taken off the way that I had hoped?

I am convinced the product itself is not the problem. People seem to genuinely appreciate the content I make. I did a survey to see why people cancelled, and the most common reason is they simple no longer use Clojure. The only complaint about the product itself is that there’s not enough new content coming out. This is understandable, but it’s also not something I can do much about at this point. And at 12 USD per month I think it’s fair to say people are getting their money’s worth.

In fact I’ve been meaning to raise the price for some time now, but since February sign-ups are barely keeping pace with cancellations, which has made me hesitant. At the same time I’m afraid that people think the low price reflects the quality of the content. So before long prices will have to go up, to make it clear that this is a luxury product, not fast food.

So if the product is good, then it follows that the problem is lack of marketing. Saying I haven’t done enough marketing is stating the obvious. So far all I’ve really made use of is social media and content marketing. Twitter and r/Clojure are two good sources of traffic.

There’s a rule of thumb that half of your time and effort should be spent on marketing, and the other half on developing the product. Most of my time goes into creating content, and hustling freelance gigs. I have a long list of things to try out though, but acting on them will take time.

So for the time being I need to accept that Lambda Island will remain more of a side gig then a primary source of income. Approaching it from that angle will give me a lot more peace of mind, and will give me time to gradually grow it into something that can stand on its own two feet.

So my plan is to stick to the current two-to-three week publishing schedule. I have a two freelance gigs that I’m wrapping up at the moment, and after that I’m looking to do ClojureScript contract work for two days a week. That should give me enough financial stability to worry less, and spend those three other days working productively on Lambda Island.

Thanks for reading this far. I felt it was important to tell this story, so people in the community know what’s up. I strongly believe in the power of open and honest communication, and with posts like these I want to take you all along on this journey.

Some people have asked what they can do to help. Here are a few things you can do,

  • Sign up for a subscription
  • Get your company to sign up for a team membership
  • Get your company to sponsor a video
  • Try the free trial and give me feedback
  • Tell your friends about Lambda Island, tell people what you like about it
  • Share links to the blog posts, freebies, the REPL guide, on Twitter/Facebook/Reddit/Slack

Thanks for listening, here’s to the next year of Lambda Island!

🡅 Comment on /r/Clojure

About the author

Arne divides his time between making Clojure tutorial videos for Lambda Island, and working on open-source projects like Chestnut. He is also available for Clojure and ClojureScript training and mentoring. You can support Arne through his Patreon page.

More blog posts

Clojure Gotchas: "contains?" and Associative Collections

When learning a programming language we rarely read the reference documentation front to back. Instead someone might follow some tutorials, and look at sample code, until they’re confident enough to start a little project for practice.

From that point on the learning process is largely “just in time”, looking up exactly the things you need to perform the task at hand. As this goes on you might start to recognize some patterns, some internal logic that allows you to “intuit” how one part of the language works, based on experience with another part.

Developing this “intuition” — understanding this internal logic — is key to using a language effectively, but occasionally our intuition will be off. Some things are simply not obvious, unless someone has explained them to us. In this post I will look at something that frequently trips people up, and attempt to explain the underlying reasoning.

Dates in Clojure: Making Sense of the Mess

You can always count on human culture to make programming messy. To find out if a person is a programmer just have them say “encodings” or “timezones” and watch their face.

In Java, and hence Clojure, there are half a dozen different ways to represent dates and times, which can lead to confusion, needless type coercion, and inconsistent code. In this post I’ll give you a quick lay of the land, and some tips to make it all a bit easier to deal with.

Representing Time

Clojure Gotchas: Surrogate Pairs

tl;dr: both Java and JavaScript have trouble dealing with unicode characters from Supplementary Planes, like emoji 😱💣.

Today I started working on the next feature of lambdaisland/uri, URI normalization. I worked test-first, you’ll get to see how that went in the next Lambda Island episode.

One of the design goals for this library is to have 100% parity between Clojure and ClojureScript. Learn once, use anywhere. The code is all written in .cljc files, so it can be treated as either Clojure or ClojureScript. Only where necessary am I using a small amount of reader conditionals.

Simple and Happy; is Clojure dying, and what has Ruby got to do with it?

The past week or so a lot of discussion and introspection has been happening in the Clojure community. Eric Normand responded to my one year Lambda Island post with some reflections on the size and growth of the community.

And then Zack Maril lamented on Twitter: “I’m calling it, clojure’s dying more than it is growing”. This sparked a mega-thread, which was still raging four days later. A parallel discussion thread formed on Reddit. Someone asked if their were any Clojure failure stories. They were pointed at this talk from RubyConf 2016, which seemed to hit a lot of people right in the feels, and sparked a subthread with a life of its own.

Meanwhile Ray, one of the hosts of the defn podcast reacted to the original tweet: “I’m calling it: Clojure is alive and well with excellent defaults for productive and sustainable software development.” This sparked another big thread.

Loading Clojure Libraries Directly From Github

Did you ever fix a bug in an open source library, and then had to wait until the maintainer released an updated version?

It’s happened to me many times, the latest one being Toucan. I had run into a limitation, and found out that there was already an open ticket. It wasn’t a big change so I decided to dive in and address it. Just a little yak shave so I could get on with my life.

Now this pull request needs to be reviewed, and merged, and eventually be released to Clojars, but ain’t nobody got time for that stuff. No sir-ee.

Writing Node.js scripts with ClojureScript

In the two most recent  Lambda Island episodes I covered in-depth how to create command line utilities based on Lumo, how to combine them with third party libraries, and how to deploy them to npmjs.com.

However there’s a different way to create tools with ClojureScript and distribute them through NPM, without relying on Lumo. In this blog post I want to quickly demostrate how to do just that.

To recap, Lumo is a ClojureScript environment based on Node.js, using bootstrapped (self-hosted) ClojureScript. This means the ClojureScript compiler, which is written in Clojure and runs on the JVM, is used to compile itself to JavaScript. This way the JVM is no longer needed, all you need is a JavaScript runtime to compile and run ClojureScript code, which in this case is provided by Node.js. On top of that Lumo uses nexe, so Lumo can be distributed as a single compact and fast executable binary.

Announcing lambdaisland/uri 1.0.0

I just released lambdaisland/uri, a pure Clojure/ClojureScript URI library. It is available on Github and Clojars.

This is a small piece of the code base that powers lambdaisland.com. It’s inspired by Ruby’s Addressable::URI, the most solid URI implementation I’ve seen to date, although it only offers a small part of the functionality that library offers.

It’s written in pure Clojure/ClojureScript, with only minimal use of .cljc reader conditionals to smooth over differences in regular expression syntax, and differences in core protocols. It does not rely on any URI functionality offered by the host, such as java.net.URL, so it’s usable across all current and future Clojure implementations (Clojure, ClojureScript, ClojureCLR).

re-frame Subscriptions Got Even Better

Up until recently, to use re-frame subscriptions in Reagent views, you had to use a form-2 component.

A form-2 component is a function that returns another function, which does the actual rendering of the component to hiccup. In contrast, a form-1 component renders the hiccup directly.

;; form-1
(defn todo-item [todo]
  [:div.view
   [todo-checkbox (:id todo) (:completed todo)]
   [:label {:unselectable "on"} title]
   [:button.destroy {:on-click #(dispatch [:todos/remove (:id todo)])}]])

;; form-2
(defn todo-item [todo]
  (fn [todo]
    [:div.view
     [todo-checkbox (:id todo) (:completed todo)]
     [:label {:unselectable "on"} title]
     [:button.destroy {:on-click #(dispatch [:todos/remove (:id todo)])}]]))

Game Development with Clojure/ClojureScript

This weekend it’s Ludum Dare again, the world’s longest running game jam. The idea is that, alone or with a team, you build a game in a weekend based on a certain theme.

We got a little team together here in Berlin, and so I’ve been reviewing what options there are for someone wanting to build a game in Clojure or Clojurescript.

The good news is there are plenty of options, as you’ll see from the list below. You can do desktop games, browser based games with canvas or webgl, and you can even create Unity 3D games, all from your comfortable Clojure parentheses.

Union Types with Clojure.Spec

Elm and other statically typed languages have a great feature called Union Types (also called Sum Types or Algebraic Data Types).

Here’s an example taken from Elm. Suppose your system used to represent users as integers, maybe just an auto-incrementing primary key, but then switched to UUIDs represented as strings.

To correctly model this situation, you need a way to create a type that can be either an integer or a string, that’s what union types give you.