In this post, I will be sharing details about the tools and technologies we use at Cartman, and how they set us apart. How they make us think differently.

Our bold claim is that a small team with seniority and sharp tools is able to deliver software product with improved quality, efficiency, and cost basis compared to a much larger team of developers.

How is it possible? Let's start by considering team composition. A larger team, or perhaps even multiple teams, require more management and processes. It becomes increasingly difficult to keep everyone on the same page. However, a smaller team can be more agile and efficient, with less bureaucracy and fewer obstacles to achieving goals. As the team size increases, the proportion of effort spent on maintaining the process also increases, leaving less time for creating value.

If the above statement is true, then why do most companies have such large teams of developers? The answer lies in the fact that, despite efficiency, often the capacity to deliver is more crucial. Therefore, the issue of delivering more value with fewer people needs to be addressed. At Cartman, we tackle this challenge by utilizing best-of-breed tools and software development practices. Additionally, we place high emphasis on the seniority of our team, as we believe that experience and knowledge are key factors in delivering quality results.

We heavily rely on functional programming and prioritize simplicity whenever possible. Keeping things simple is not always easy, but it allows us to move faster. We created our own set of principles that outline some of the practices we use and found useful. Some of these practices are not commonly seen in our industry, such as using immutable data structures, prioritizing data over code, and minimizing the amount of code that needs to be written. In fact, a large team can quickly create so much code that it becomes a maintenance burden, slowing down the entire team.

We use the Clojure programming language and its ecosystem to develop software. Clojure has a unique value proposition: it can run on the JVM and be compatible with existing the Java ecosystem. Alternatively, by using its close cousin, ClojureScript, we can utilize the JS and Node ecosystem. Clojure offers immutable data structures, code as data approach (homoiconicity) and an excellent model of concurrency with Software Transactional Memory. Additionally, it provides a great developer experience compared to other solutions in the market.

Code written in Clojure can be up to ten times shorter than equivalent code written in other languages, such as Java. Clojure code with functional approach tends to focus on resolving real-world business issues with minimal boilerplate code. However, the main benefit of Clojure is not just its syntax or code reduction, but its ability to introspect and change code in real-time in a REPL (Read-Eval-Print Loop), allowing developers to see changes immediately. In Clojure, you usually don't need to bring up a debugger since you can develop and run your code simultaneously.

Imagine a traditional e-commerce application with a complex bug in the checkout process, after some input fields have been filled out. A Clojure developer can start the application once, get it to the correct state, and then test it with some inputs. The developer can change the implementation, redefine some functions, test again, and see the results in real-time. At no point is there a need to restart the application or the process of filling in data in the checkout. Furthermore, the output of this experimentation can be captured to replay later or create test cases.

This concept truly changes the way you think about software development. It unifies the development and running of software, making them no longer separate. We are able to develop and run software simultaneously and make any changes as we want on a running system.

Clojure is not the only tool that helps us delivering software faster. In other areas of software development, we also prefer simple solutions over more complicated ones. Although our industry is constantly evolving, not every new solution is appropriate for every situation.

Many new "paradigms", such as microservices, GraphQL, and a plethora of frontend solutions, are being introduced in the industry. While we can certainly work with these tools, they may not make sense in real-world applications or may only make sense at a certain scale. In the long term, simpler solutions are easier to develop, change, and maintain. This conservative thinking avoids falling into the trap of playing with the latest and coolest technologies, instead of focusing strictly on solving client needs.

Overall, we at Cartman pride ourselves on our commitment to delivering high-quality projects and products efficiently. By utilizing tools like Clojure and prioritizing the seniority of our team, we are able to create software for our clients effectively.