CLOJURE, A not so secret weapon


Clojure is not a new language anymore, it was created on 2007 by Rich Hickey, but I discovered in 2013 while I was searching alternatives to Java for a new project. Two things converged at that moment, the first one is that  I was searching for a library, or a tool or language for coping with the concurrency in an easy and stable way, the second one, is that I was reading the book Hackers and Painters from Paul Graham where I ended up convinced to at least try Lisp in some way, and Clojure is a Lisp dialect.



I will not go into the details about specific aspects that I discovered in my first project with Clojure, instead, I will highlight the things that, to me, are the magic of Clojure. The most notable change for a developer that start coding in Clojure is the REPL (Read, Eval, Print Loop)  way, the thing is that the interpreter is continually reading, compiling and executing code in a way that you never lose the state while you are changing the code. For ‘state’ I mean the data that your program reads, transform and finally build with specific logic (functions) with it, the state is the data structure that we,  as programmers, use to model and solve real problems.

The ability to code incrementally, having the time to examine every data structure, every piece of function, being able to rehearse a small routine  (a S-expression in LISP) to verify the result with the data you are seeing (your state); all these aspects constitute a huge shift in your paradigm. I felt that new ways of reasoning about my code were possible only using a RPEL style. It was a different feeling compared with my previous experience learning  Python, although you can perceive the syntactical changes between languages, the core concepts remain essentially the same (as it happens between Javascript, C++, or Java), but with Clojure, it offers you a new way of thinking, because it certainly is, its name is Functional Programming.

Programming with functions is supposedly the foundation for Functional Programming, but the real benefit in Clojure, qualified as a functional language,  is the presence of its immutable Data Structures. I was not aware of this during my OOP (Object Oriented Programming) years, but after read the paper “Out of the Tar Pit”  I understood that a lot of the complexity (and bugs!) were hidden into the state, which for OOP disperse through objects.

In Clojure is possible to examine all the data because it is expressed  with its own syntax (EDN: Extensible Data Notation ) in a transparent way, most of the time the programmer is encouraged by the language to develop in a way that is close to the data, avoiding to create additional  layers on top the data, which by the way, tends to hide the very nature of the business logic. This aspect is so common that has its own name: Data Driven Development (DDD) :-).

It is not my purpose in this entry to explain the language, you can find a lot of resources for learning it in Internet (see the Links at the bottom), but let me just highlight the benefits in efficiency you can obtain if you create solutions using Clojure, I will dive into those benefits with concrete references to the source code and libraries I used to build Web applications in other posts.

REFERENCES


Comments

Post a Comment

Popular posts from this blog

Image
How  ‘resolve have solved my problem When I found Clojure, it was with the intention to implement a high concurrent application to manage provisioning commands for Huawei Equipments. Meanwhile I was learning about  the concurrent toolset that comes with the language, then I found a small but not less important feature in Clojure: the use of symbols. After diving into this feature I discovered that the majority of Lisps dialects has it. Having symbols means an additional  level of abstraction for development, the good news is that is 100% integrated with the evaluation process of Clojure, so you can create logic in your programs that explode this feature, as I did in my project. The problem was that I had to implement different functions to be dispatched depending of the command  received, I wanted to avoid write a switch/like structure for dispatching. T he commands had this syntax: ADO $ 19203212 CWI CWT $ ADO $ 19200242 CPC PRIOR $ Y $ DEO $ 16200213...
Read more
Programming I started in programming writing small functions for my Casio FX-680 calculator during my first engineering undergraduate years, then I took a programming course where I learned Pascal and implemented numerical routines, but I could not write a complete screen-oriented application because the library of objects to build menus and dialogs was too big for me at that time. Then I found Linux, and read C code, I downloaded patches from internet and apply them using commands like patch, diff, etc. It was a side interest activity consisted of following instructions and learning through the process, I never wrote a serious program in C from scratch. I will describe what I have achieved in the main languages I worked professionally. C++ was the language I was kind of forced to learn because of a job assignment. It took me  two months and had a happy end after completing a patch in a medium (10k lines of code) size software and deployed in production. ...
Read more