We and Clojure

The first deal that led to starting Flexiana was an ERP that had no bugs. The client was a midsize telco company (the second-biggest provider of VOIP & call center infrastructure in the Czech Republic. Jiri Knesl, Flexiana founder (at that time the only person in the company) used Clojure, Postgres & a couple of other technologies. In the first 2 years, there were only 2 production bugs, both were in the Postgres part. There were no bugs in the Clojure part of the application.

It was like magic. Clojure didn’t just deliver high-quality software. It was also very expressive. Later the first app got DSLs for API, CRUD, access rights, etc. and it showed that:

  • The code remains flexible
  • The code was very easy to integrate and extend
  • Things that would be dozens of lines and 5-6 applied design patterns in OOP C-like languages became just a few lines of code using High Order Functions, partial application, etc.
  • Clojure allows us to work on a small scale and get the productivity of scripting languages but also gives us tools for large-scale development. It’s great for short throwaway scripts and little services as well as for crucial ERPs that are the engine of companies.

After 8 years of usage, we have grown to become one of the TOP10 largest Clojure teams in the World (in fact after Nubank and Cognitect We don’t know any larger Clojure development team).  And our collective experience shows more Clojure qualities. Some of them are:

  • Clojure and later ClojureScript are very versatile and suitable for a wide range of jobs
  • the language and the ecosystem is very stable and the team is under no pressure to rewrite the whole thing or parts frequently as often happens in other languages

The stability might seem weird, one might think Clojure lacks progress. But when you are so far ahead, you can stay where you are and still be the first and the best. Plenty of things have changed anyway (we switched from Luminus to Duct, from Prismatic Schema to Clojure.spec, we don’t use core.async when we don’t have to, we moved from Om to re-frame etc.), but truth is that the changes are mainly changes that drive us to more idiomatic Clojure. The underlying principles are great. So the only thing you have to do is to learn how to apply them.

We at Flexiana are committed to Clojure as our language #1 on the server-side and ClojureScript as our language #1 on the client-side. As our operating profit will allow it, we promise we will budget to give back to the community. Mainly:

  • Develop & maintain open-source Clojure and ClojureScript libraries
  • Support Clojure core development
  • Sponsor more Clojure conferences (so far we have sponsored 4 conferences across the whole of Europe, if there were no COVID, it would be 6 so far)
  • Promote Clojure and ClojureScript to other people and companies to make the whole ecosystem larger
  • Hire & train more people to become Clojure and ClojureScript craftsmen

We are incredibly grateful for the work of Rich Hickey, the Cognitect team and the whole community and we promise to give back a substantial percentage of our profit back to it.

Clients we have helped with clojure

Why Clojure

Immutability

Practice taught us that a state and mutable changes are root of errors. Clojure comes with immutable data structures as first-class citizens.

Syntax

Clojure syntax is very simple and consistent, easy to learn. No need to learn new syntax when a new feature is added to the language.

Platform independency

Clojure is platform-independent. In general it’s run on JVM, but it can be run in a web browser or NodeJS.

Mature

It’s here since 2007 as a modern Lisp based on the best experience of computer science.

Functional

In general, Clojure is a functional language that allows us to write pure functions, describe side effects as data, use recursion, compose a program from small functions, etc.

REPL

Read-eval-print loop as a main programmer’s experience. A program can be composed by directly executing code from an editor in a runtime machine and seeing the result. The runtime machine could be anywhere on the Earth.

Concurrency

Build-in capabilities for concurrent programming as Software Transactional Memory and Agent System.

Polymorphism

It allows an extensible and dynamic polymorphism.

Code as data

The code itself is data. A program can manipulate the code via macros. Build-in data format called EDN.

Interoperability

It can use platform-specific features. Reuse Java libraries on JVM or communicate with a web browser API.