DEV Community: Камило Куньа

Learning Clojure, part VII

Камило Куньа — Wed, 18 May 2022 00:22:53 +0000

We learned how to use functions and some basic data structures, now we finally will start to make things a little more interesting as define values and functions.

Symbols

Symbols are a different kind of value, they are a name that represents a value. We can define symbols using the def function.

(def trainer "Green")
;; returns => #'user/trainer

(def team ["Pidgeotto" "Rattata" "Abra" "Charmander"])
;; returns => #'user/team

When we evaluate values we get them as return, as an example:

"Red"
;; returns => "Red"

8
;; returns => 8

But symbols evaluate for the value it's referring to:

trainer
;; returns => "Green"

team
;; returns => ["Pidgeotto" "Rattata" "Abra" "Charmander"]

When we define symbols we're not binding it directly to a value, instead, it does it through a Var a mechanism that is used to refer to values.

When we defined our symbols trainer and team you should notice that it returned the name with #'user/ in front of it. It's saying we defined a var that's in the user namespace and that's because symbols are bound to a namespace and we can call them in the fully qualified name (we just don't have to do it when we're in the same namespace of the symbol):

user/trainer
;; returns => "Green"

user/team
;; returns => ["Pidgeotto" "Rattata" "Abra" "Charmander"]

Is important that you have the attention that REPL always starts in the user namespace if you running these commands from a project maybe you have a different one declared at the beginning of the file. We can also redefine or define new namespaces as we see in the next parts.

let

Sometimes we want to define symbols that are just used locally instead of as global values in the namespace and we use the let function to do it, this function receives a vector with a pair number of elements ordered as symbols and values that are only available inside the same block (parenthesis) as let.

(let [region "Kanto"
      place  "Route 1"]
  (str "You are in " place " of the region " region))
;; returns => "You are in Route 1 of the region Kanto"

region
;; returns => Syntax error compiling at (REPL:0:0).
;;         => Unable to resolve symbol: region in this context

We'll use let a lot when we're defining our functions. Defining local variables helps a lot in the legibility of our code since it helps to figure out what each value means.

Functions

As we have seen until this point we can evoke functions using forms (also called expressions) that have the syntax (operator arg arg args...), but it's time to learn how to define our functions.

Anonymous functions

Sometimes we just need a function that we need to pass as a parameter or just use briefly and they're the most basic use of functions, as they will be used just once we don't name them so they're now as anonymous functions.

We can define an anonymous function using the fn function that receives a vector with the parameters and then the function definition.

;; How define an anonymous function
(fn [x y] 
  (println "Making a vector...")
  [x y])
;; returns => #object[user$eval2048$fn__2049 0x6cce008e "user$eval2048$fn__2049@6cce008e"]

;; How to call an anonymous function
((fn [x y]
   (println "Making a vector...")
   [x y]) "The answer is " 42)
;; returns => Making a vector...
;;         => ["The answer is " 42]

Clojure doesn't have any kind of instruction on what is the return of a function, instead, the last value of the body of the function is returned from the function (as the vector in our example above).

Functions always return some value in Clojure (even if it's a nil value).

Shorthand anonymous functions

Is possible to use # in front of the parenthesis to define an anonymous function.

(#(str "Hello " "Clojure!"))
;; returns => "Hello Clojure!"

Is also possible to use % for shorthand as a parameter.

(#(str "Hello " %) "Camilo")
;; returns => "Hello Camilo"

When the function expects multiple parameters is possible to number % as %1, %2...

(#(Math/pow %1 %2) 2 8)
;; returns => 256.0

Naming functions

We can use the def function to bind an anonymous function (that is a value) to a symbol and it will help us to call them as many times we want intuitively.

(def sum-numbers (fn [& args] (reduce + args)))
;; returns => #'user/sum-numbers

(sum-numbers 7 7 7)
;; returns => 21

(sum-numbers 4 9 3 6 2 8)
;; returns => 32

(user/sum-numbers 14 39 43 -60 21 83)
;; returns => 140

& is a special form in Clojure that is used to package the rest of the parameters in a vector. So in parameter definition [x y & z], this function will have 2 parameters x and y, and all other values passed after it will be in a vector called z. While in our case [& args] we packed all parameters in a vector called args.

Defining functions with defn

There's syntactic sugar for defining functions in a more readable way is the defn, you can think of it as (+ def fn) => defn. The defn gets as parameters a symbol, a vector of the function parameters, and the body of the function.

;; Function definition with defn
(defn name
  "Optional docstring that describes what this function does." 
  [params]
  ...params)

;; example
 (defn sum-evens [numbers]
   (->> numbers
        (filter even?)
        (reduce +)))
;; returns => #'user/sum-evens

Functions with multiple arities

Arity is the number of arguments or operands taken by a function.

We can specify that a function can have multiple parameter possibilities, for this instead of passing a vector of parameters we will wrap each definition in a form where each receives a pair with a vector and the definition, for this work each definition has to be different from other.

(defn make-point
  ([x] [x 0])
  ([x y] [x y]))

(make-point 5)
;; returns => [5 0]

(make-point 5 4)
;; returns => [5 4]

See you soon!

Now we're starting to have fun, with functions we can make a lot of useful things and I challenge you to start doing it. It's a good time to build simple functions that do things like flip a number order or a fizzbuzz exercise.

In the next chapters, we will continue to explore Clojure collections and learn how to use Hash-Maps to structure our data.

GambiConf — Why do we need a new tech event?

Камило Куньа — Wed, 11 May 2022 15:39:29 +0000

GambiConf is the event I’ve always desired to happen, and it fits a specific unmet demand in tech conferences.

Tech events like Code BEAM, BrazilJS, Strange Loop Conference, and GOTO Conference are great, but they usually end up fitting into two categories:

its a conference focused on an environment (e.g., Code BEAM is about languages that run on BEAM, BrazilJS about JS and web in general)
its a conference focused on forefront technologies and research, normally useful for industry (e.g., Strange Loop Conference and GOTO Conference)

It’s all good. If you’re looking for cutting-edge technology check out the GOTO Conference playlist. If you’re curious about the latest internet developments, then you’ll enjoy the BrazilJS playlist.

But it’s missing a vital thing: we are people. We like to do 4fun projects. We like to develop pet projects exploring random things just for the sake of curiosity. We also want to share our achievements. But unfortunately, it’s harder to find a place to share them.

Pet projects usually aren’t focused on being used in the industry, thus serious events focused on the industry likely won’t accept them.
Another feature that makes it harder to talk about random subjects is the technology requirement. Let’s say that I want to talk about how to build a computer using water — but since it isn’t related to any programming language or environment, events focused on these features often won’t accept it.
Sometimes you can try to comply: suppose you got to run DOOM in a PDF file. It’s fun, and you want to share it. Then you notice that the PyCon conference is coming up. Since you used a Python script to achieve it, you can try to apply it to PyCon… but since the proposal is outside the audience’s normal expectations, there may not be much interest.

GambiConf is the solution! This is an event for mind-blowing personal projects and random computer subjects that are fun. We focus more on the purpose of the presented projects, the unique nature of the sessions, and what one can learn from a random, very unusual idea.

If someone needs to quench their thirst for curiosity, they can rely on GambiConf. It’s also the place to be inspired for their next personal project.

These kinds of unusual talks are helpful to learn a new topic. For example, a talk about running DOOM in a PDF file can cover how the PDF format works, its specs, other related formats, etc. A talk about making a computer using water can cover what is computation itself, explain the Antikythera mechanism, and so on.

Of course, there are events with a purpose similar to GambiConf. As far as I know, the closest is !!Con. It’s a place to find fun talks and crazy personal projects that surprise you. But its talks are limited to 10 minutes. It’s good for getting some highlights, but someone can learn a lot more from a random topic that takes time for the speaker to explain in more detail. That’s why in GambiConf, the speaker has the freedom to decide on the length of their talk. As a result, GambiConf not only fits short talks like !!Con does, but also talks that explore a broader subject.
I would also like to also mention SIGBOVIK, which is like when someone took the joke too seriously. They publish a “paper” with all the crazy ideas and have a fun “academic congress”. The diverse subjects presented at this event have a close spirit that I want to bring to GambiConf.
You can check the !!Con YouTube channel and the annals of the previous SIGBOVIK editions.

I love both events. They inspired me a lot to make GambiConf.
In the end, GambiConf is a mix of these events, my desire to have more events unrelated to the industry, focused on 4fun talks, and flexible time slots for speakers to cover the subject as far as they want.

In the first edition of GambiConf, we achieved this goal, and we had a couple of fun talks covering many subjects with an excellent technical level. I would like to highlight some of them (all in Portuguese):

Theory and research in the computing field, covering mind-blowing topics: How to build computers using only water, and Computational creativity
Fun personal projects: How to run DOOM on an oscilloscope, Making your own printer driver, Weather station using JS only, and Let’s be creative using hardware + emulators
Innovative solutions for a real problem: Self-Man-in-the-Middle, Google Sheets, a CMS with potential, and Segfault as Optimization

The first GambiConf edition was in Portuguese since it was focused on a Brazilian audience (that’s also why the mascot is a golden lion tamarin). Since it had fantastic feedback, I decided to expand it to Europe, now in English. GambiConf is a good way to encourage the culture of making 4fun projects with computers, learning random subjects, and sharing them. As far as I know, there is currently no event like this in Europe, since both !!Con and SIGBOVIK are USA-based.

If GambiConf sounds fun to you, you are invited to apply to the CFP and be present to watch the talks. Let’s make computing more fun!

Check our site: https://gambiconf.dev/
Follow us on Twitter: https://twitter.com/gambiconf
Facebook page: https://www.facebook.com/GambiConf-102543485504335
Linkedin page: https://www.linkedin.com/company/gambiconf

Learning Clojure, part VI

Камило Куньа — Fri, 06 May 2022 02:14:36 +0000

We already learned how to use lists and the importance of this data structure in Clojure in the previous post. Now we gonna learn another important data structure: Vector.

What are vectors?

Vectors as lists are immutable persistent data collections that can hold any value. They can be created using the vec function passing a collection of values or passing the values directly between square brackets.

;; (vec collection)
(vec '("Red" "Green" "Blue"))
;; returns => ["Red" "Green" "Blue"]

["Gold" "Silver" "Crystal"]
;; returns => ["Gold" "Silver" "Crystal"]

Vectors vs Lists

Both vectors and lists are collections of data, but they differ a lot in how each one of them works. The first main difference you probably notice between them is while lists are written using parenthesis, vectors are written using square brackets.

'("List" 1 2 3)
;; returns => ("List" 1 2 3)

["Vector" 1 2 3]
;; returns => ["Vector" 1 2 3]

Looking now they seem to do the same thing, but the data structure underlying these collections are different and have a lot of differences in practical use.

(class '("List" 1 2 3))
;; returns => clojure.lang.PersistentList

["Vector" 1 2 3]
;; returns => clojure.lang.PersistentVector

While lists, as we seem, are noncontinuous values in memory that hold a value and a reference to the next value, vectors are values that are continuous in memory so the elements are indexed and can be fast accessed by their index position using the function nth.

;; (nth collection index)

(nth ["Charmander" "Pikachu" "Buterfree"] 0)
;; returns => "Charmander"

(nth ["Charmander" "Pikachu" "Buterfree"] 2)
;; returns => "Buterfree"

Image: "Vectors representation" made by the author is copyleft material under unlicense.

Adding values

Another great difference between them is when we use the conj function to add an element to the collection because the function will add the element in faster way to the collection:

In lists is faster to add a new element to the beginning since that to do it it's not necessary to go through the entire list to add it in another position.
In vectors, the element is added in the last position since it just gets the last index and adds it after.

Image: "Conj vector vs list" made by the author is copyleft material under unlicense.

We can see this with some examples:

(conj  '("Charmander" "Pikachu" "Buterfree") "Zubat")
;; returns => ("Zubat" "Charmander" "Pikachu" "Buterfree")

(conj  ["Charmander" "Pikachu" "Buterfree"] "Zubat")
;; returns => ["Charmander" "Pikachu" "Buterfree" "Zubat"]

Vectors and Lists

We can use the nth to efficiently access a value by its position, but we can also use any of the functions we see in lists before as well. They can be used to iterate over the vector as we can do with lists and other collections.

first

The first function returns the element at the beginning of the vector.

(first ["Brock" "Misty" "Lt. Surge" "Erika"])
;; returns => "Brock"

second

The second function returns the second element of the vector.

(second ["Brock" "Misty" "Lt. Surge" "Erika"])
;; returns => "Misty"

last

The last function returns the element at the end of the vector.

(last ["Brock" "Misty" "Lt. Surge" "Erika"])
;; returns => "Erika"

rest

The rest functions return the vector as a list without the first element.

(rest ["Brock" "Misty" "Lt. Surge" "Erika"])
;; returns => ("Misty" "Lt. Surge" "Erika")

When we should use lists over vectors?

If you intend to add and retrieve values at the beginning or at the end of the collection all the time, then a list will be far more efficient than a vector.

On another side, if you need to add and retrieve values in the middle or in indexed positions then a vector will be far more efficient than a list.

You should consider it when choosing which of them you will use, as general advice usually vectors are more frequently used than lists in most cases.

See you in the next part!

Having 2 different collections that look so similar and work so different can be a little confusing at begging especially if you don't know how these data structures are made but don't worry this will become natural as you get used to Clojure.

Learning Clojure, part V

Камило Куньа — Tue, 03 May 2022 19:11:15 +0000

In the previous part we learnt what are forms, how Clojure evaluates them into values and how to return code as data. Now we gonna learn about a fundamental underlying data structure behind all of it: the list.

The meaning of being LISP

The name LISP derives from "LISt Processor" and the reason for it is because everything in the language is in fact a list. What we call as a "list" is in fact the Linked List data structure that is represented in Clojure and all other historically LISPs as values between parenthesis separated by a space.

("This" "is" "a" "list")

As we can see the forms that compose the language syntax are a linked list with a function as the first element that is applied in all the remaining elements from the list.

Image: "Forms as linked lists" made by the author is copyleft material under unlicense.

(str "This " "is" " a " "list")
;; returns => "This is a list"

(apply str (list "This " "is" " a " "list"))
;; returns => "This is a list"

This linked list is formed with pairs of elements e.g. (1 (2 (3 ()))) that usually are called cons. In most LISPs implementations cons are a structure of a pair of elements (A.B) in Clojure the underlying structure are Seqs that we'll see later, but the language has some syntax tricks so we call it cons as well and that's what we'll use for now.

We can create lists as creating cons cells where each one receives the value of the element as A and the next cell as B in (A.B):

(cons "This" (cons "is" (cons "a" (cons "list" '()))))
;; returns => ("This" "is" "a" "list")

As we can see the last element of each list is a nil cell '() that represents the end of the list and it's ignored when we print all elements since it's just an empty value.

Creating lists of values

Since forms are part of the structure of the language we cannot just create a list of values in code mode since Clojure evaluates every list as a form.

If we try to simply enter our list on REPL we'll get an error:

("This" "is" "a" "list")
;; returns => Execution error (ClassCastException) at user/eval2051 (REPL:1).
;; => class java.lang.String cannot be cast to class clojure.lang.IFn (java.lang.String is in module java.base of loader 'bootstrap'; clojure.lang.IFn is in unnamed module of loader 'bootstrap')

Most times you see errors about clojure.lang.IFn is because something related to functions, in this case, is because "This" can't be read as a function since Clojure expects it to be an operator that will be applied to the remaining elements.

For we create lists we need to quote them so they will be treated as data:

'("This" "is" "a" "list")
;; returns => ("This" "is" "a" "list")

Or we can instead use the list function as we did in example above:

(list "This" "is" "a" "list")
;; returns => ("This" "is" "a" "list")

As Clojure is a dynamic language lists can hold any given value:

'(3.1415 "PI" \π)
;; returns => (3.1415 "PI" \π)

In this case, we created a list that contains a float, a string and a char.

Getting values from a list

The main thing we have to know about lists is that when we want to get a value from it we have to access all values before it. Imagine we have the following list:

'("Brock" "Misty" "Lt. Surge" "Erika")

If we want to access "Lt. Surge" that is the third element first we have to access the two elements before it "Brock" and "Misty". This happens since it's a linked list and we don't have a direct reference to the position of each value, as the close element is to the end of the list longer will be the time needed to get its value.

To get elements we usually have three functions that we combine to go through the list: first, second, last, and rest.

first

The first function returns the element at the beginning of the list.

(first '("Brock" "Misty" "Lt. Surge" "Erika"))
;; returns => "Brock"

second

The second function returns the second element of the list.

(second '("Brock" "Misty" "Lt. Surge" "Erika"))
;; returns => "Misty"

last

The last function returns the element at the end of the list.

(last '("Brock" "Misty" "Lt. Surge" "Erika"))
;; returns => "Erika"

rest

The rest functions return the list without the first element.

(rest '("Brock" "Misty" "Lt. Surge" "Erika"))
;; returns => ("Misty" "Lt. Surge" "Erika")

Getting specific values

Most times when we iterate over lists we combine some of these functions to reach the desired element, let's imagine that we want to get the third element.

(first (rest (rest '("Brock" "Misty" "Lt. Surge" "Erika"))))
;; returns => "Lt. Surge"

When we iterate over lists we usually use recursion that's something we gonna see later and help us not have to write a lot of functions to get our data, but for now is important that you know how to use and combine them.

Adding values

There are two main functions that we use to add things to a list. The first is the cons function that as we see before is used to build lists and the second is conj which is used to create a new list adding an arbitrary number of elements to the beginning of an existing one.

(conj '("Koga" "Sabrina" "Blaine" "Giovanni") "Erika" "Lt. Surge" "Misty" "Brock")
;; returns => ("Brock" "Misty" "Lt. Surge" "Erika" "Koga" "Sabrina" "Blaine" "Giovanni")

When we use cons on other hand we build a new list with the passed exact one element on the beginning of it.

(cons "Brock" '("Misty" "Lt. Surge" "Erika"))
;; returns => ("Brock" "Misty" "Lt. Surge" "Erika")

That's all

Now you're becoming to understand LISP a little more in the next parts we'll continue exploring some of the fundamental data structures that we can use to build our programs and how to use them to structure our data.

Learning Clojure, part IV

Камило Куньа — Fri, 22 Apr 2022 03:01:11 +0000

Now we understand the basics is time to delve into the language. As we study the language is recommended that you also use the REPL to follow the code examples (and you can use an online REPL if you want to).

Syntax

As we know Clojure is a LISP and in all of its dialects what draws attention when we're reading the code is the parenthesis. In fact, when we're talking about LISP most of our code is written using parenthesis in what we call form or expression (for simplicity we can adopt form).

A form is composed as:

Image: "Form composition" made by the author is copyleft material under unlicense.

operator is an operation that receives arguments and produces a result.
...args is one or more arguments that are consumed by the operator.

In fact, Clojure as a LISP only supports two structures:

Data is the literal representation of values.
Forms.

For example when we enter a form like:

(+ 3 4 5)
=> 12

The form is composed of the operator (the function +) and the arguments (3 4 5) that are arguments passed to the function and produce 12.

This at first glance may look strange, but Clojure (and LISPs) have uniformity in its syntax. When someone programs in Java there are operations with different syntax depending on the operation and operands while in Clojure everything has always the same structure.

Evaluation

When we work with Clojure is frequent that part of the arguments of the form is other forms. As example:

(+ 5 6 (- 8 4))
=> 15

More complex forms are evaluated as follows:

Image: "Clojure form evaluation" made by the author is copyleft material under unlicense.

Data

If we append a form with apostrophe ' then the form is evaluated as data.

'(+ 1 2 3)
=> (+ 1 2 3)

When the form is evaluated as data the computer will not execute it, instead, it will return it as plain old data which we can use to perform operations on code.

This is one of the main advantages of LISP dialects over most programming languages that are mainstream. In LISP there's a concept known as homoiconicity where code is data and data is code.

The use of an apostrophe to treat forms as data is called quoting. When we quote our form everything on it is ignored and treated as a simple list containing data (and lists will be our next subject).

Let's continue the Clojure Quest

Now we started to mess with code we're barely starting. Clojure is a great language with so much yet to see and we will continue our quest to master it in the next post on this series hope have you there too.

Learning Clojure, part III

Камило Куньа — Thu, 21 Apr 2022 20:57:48 +0000

We already discussed the reasons you should try Clojure and also configured our development tools and installed Clojure.

Hello, Clojure!

As every developer knows since the dawn of computing the first program that we have to write to be successful in any programming language we're learning is print 'Hello World' on console.

For this we gonna start a new project:

$ lein new app hello-world

And open it on our IDE:

$ code hello-world

The project will have the following structure:

.
├── CHANGELOG.md
├── doc
│   └── intro.md
├── LICENSE
├── project.clj
├── README.md
├── resources
├── src
│   └── hello_world
├── target
│   └── default+test
└── test
    └── hello_world

Where:

CHANGELOG: That's a model for CHANGELOG in the project.
doc: Is a folder dedicated to the documentation of the project, it's initialized with an intro.md for writing the first steps.
LICENSE: Is a file containing the Eclipse Public License - v 2.0 the same license used in Clojure and default in most Open Source projects that use the language.
project.clj: That we're gonna declare our dependencies and configuration for the project.
README: That's a entry document and front page in remote repository for the project.
resources: Where we can put the files we want to zip in the final jar when we compile the project.
src: That's where our code will really be.
target: Where will be the compiled jar's.
test: That's where the tests will be place.

Now we can run our code using leiningen:

$ lein run

And if we want to build it as a jar (if you're not from Java and not familiar with the concept we'll explain next) for distribute we can use:

$ lein uberjar

If we want to run the generated jar file:

$ java -jar target/uberjar/hello-world-0.1.0-SNAPSHOT-standalone.jar

And we should receive the same message as before.

What's a jar?

The JAR (Java Archive) it's a compressed format of a compiled project for Java Virtual Machine (JVM). When the project is compiled to a JAR File all the JVM bytecode generated will be compressed in this file together with metadata and additional resources needed to run the code.

This is analog to what most people think about an auto executable .exe or .dll on Windows. The JAR file is the format that is used to distribute programs written to be executed in JVM or libraries to be used in languages that run on it.

How Clojure works

Clojure is 100% written in Java (and Clojure itself). In fact, the whole language runs from a JAR file that can be built from Clojure source code. But the process of compilation and execution of the code it's little different from Java.

When we run a Java program the source code is send to the compiler who will parse, tokenize, structure... the code and then compile it to a .class file that contains the compiled bytecode and that file when run will be sent to JVM who will translate it to the optimized machine code for where it's running.

"Traditional Evaluation (Java)" by Rich Hickey is copyrighted material of clojure.org

By other way, when a Clojure program is evaluated first it passes by a special step that's the reader a program written for receive the source parse it and return all code structured in some data structure, only after it the code gets in compiler. In Clojure the compile only receive data structures and never text, separating the reader from compiling makes it easier to process macros and substitutions. As most times the Clojure program is running in live mode (like REPL) the bytecode is immediately sent to JVM that caches and executes it.

"Clojure Evaluation" by Rich Hickey is copyrighted material of clojure.org

How our hello-world JAR works

If we use an online Java decompiler tool to analyze the compressed bytecode in the JAR we created when compile our project we'll get that the JAR has a folder structure like that:

hello-world-0.1.0-SNAPSHOT-standalone.jar
├── clojure
└── hello-world

Where the clojure folder contains the compiled bytecode of the reader and compiler altogether with the language source compiled.

While the hello-world folder have the original Clojure file we written and also helper classes to run main and these same files compiled in Java, but the compiled result are internal symbols of the Clojure language and not a simple and readable Java program.

So every time we compile our Clojure apps for a JAR to be run in JVM the JAR itself contains also the whole code needed to run Clojure including the the language functions, reader and compiler that can be executed if needed.

See ya!

Our Clojure journey is still far from the end, now we can understand how the process compilation and execution of Clojure works we can understand how it's different from a Java project and how JVM can execute the JAR since it was not thought to run Clojure code. Hope to see you in part IV.

Learning Clojure, part II

Камило Куньа — Wed, 20 Apr 2022 00:18:21 +0000

Now you're convinced that is a good idea learn Clojure (and if you not I recommend to read the part I) we'll start the practical part installing the language and all the tools that we need for program in Clojure.

I'll not cover the process on Windows, most of things like SDKMan! only work on Linux/Mac Operating Systems, if you're using Windows I would recommend you to use WSL to follow this tutorial.

Install SDKMan! and Java

The first thing to do is install Java. Clojure is entirely written in Java (and Clojure itself) we need have Java installed and configured in our computer not only to run most of the tools that we use to program in Clojure, but also to run Clojure itself.

To do this we will install a bash tool called SDKMan! this is a version manager tool for all JVM languages (including our beloved Clojure). To install it we have to run the command in our terminal:

$ curl -s "https://get.sdkman.io" | bash

After it complete the installation we have to source or open/close our terminal to load the changes in our ~/.bashrc. SDKMan is a collection of bash functions that are linked in our bash profile.

If you want to understand how the sdk function we'll use works you can use the following command on your terminal: $ describe -f sdk

Now we have to install Java on our machine. The actual Long-Term Supported (LTS) version of Java is the 17 we'll use it. In your terminal run the following command:

$ sdk install java 17.0.2-open

All right! now you can check if Java is installed and running with the command:

$ java -version

The SDKMan! not only helps you to install and configure Java as it also manages different JDKs on your computer if you want to learn more about it I recommend reading the documentation.

Install Maven and Leiningen

Now we have to install the build tools both for Java and for Clojure since we'll use them for manage dependencies and build our code. For our own luck SDKMan! also do this for us.

For install maven we have to run:

$ sdk install maven

And for install leiningen we have to run:

$ sdk install leiningen

After doing it we should have all we need to run Clojure. If you want to start doing things in REPL or just test the installation you can run it in you terminal:

$ lein repl

By the way if you need to exit the REPL just run the function (exit) on REPL.

Installing VS Code and Calva

Wait... VS Code? Why not Emacs?

Well, a lot of people following this tutorial never learned Emacs before and I won't recommend learning Clojure and Emacs at the same time because things can become messy and confusing. After all, the complexity of the ecosystem and the elisp language be so similar that can be confusing.

By other way, probably you already have VS Code installed in your computer, and even if you don't you can just use apt or snap to install it.

$ sudo apt install snapd
$ sudo snap install –classic code

After installing the IDE you can open it and install the Calva plugin it will add a lot of features to VS Code including things such as REPL integration and folding parens capabilities. To install it, open your VS Code press CTRL+P and paste this code into the open dialog:

ext install betterthantomorrow.calva

After restarting your VS Code everything will be fine for we start the development in Clojure.

Hello Clojure!

After we have all set we can start programming in Clojure by building our first project. To do this you can just open a terminal in the folder where you want your project to be created and run the following command for leiningen create our project scaffold named getting-started based on app template:

$ lein new app getting-started

And then we can open it on VS Code:

$ code getting-started

The entry point of our project will be ./getting-started/src/getting-started/core.clj file that contains a Hello World program, let's change "Hello, World!" for "Hello, Clojure!" and then run the project with the command:

$ lein run

If everything worked fine you should see the printed string printed in a newline in your terminal.

Using the REPL

One of the main advantages of using Clojure is the Read-Eval-Print-Loop (REPL) tool that helps a lot to get feedback while we're coding for work with Clojure is recommended that at least you learn to use the basics on it.

For start a REPL open the VS Code and press CTRL+ALT+C and the CTRL+ALT+J and then select leiningen and use the uberjar profile.

You will see a prompt with clj꞉getting-started.core꞉> open on the right of the code, this is our REPL window and you can run any Clojure code or part of the code you're writing on it:

clj꞉getting-started.core꞉>  (+ 1 1)
2
clj꞉getting-started.core꞉>  (-main)
Hello, Clojure!
nil

At any moment you can also put the file cursor on the closing parenthesis in your file and run CTRL+ENTER and it will send the code to REPL and display the result of it.

If you want to learn more about how to send files to REPL, how to make a partial evaluation, and everything else in Calva I recommend you to look at the docs.

I'll be back

This is just the first step in the Clojure journey, now we installed and configurated our whole development ambient we're ready to start evaluating parenthesis on our next post.

Learning Clojure, part I

Камило Куньа — Mon, 18 Apr 2022 22:30:01 +0000

What's Clojure?

Clojure is a LISP Dialect originally made to run on the JVM (Java Virtual Machine) and has been ported for the .NET and JavaScript ecosystem as well.

As a LISP Clojure adopts dynamic typing functional programming as the main programming style and as it runs on JVM and is mainly written in Java it can interoperate with Java seamlessly and run the same code on any platform that runs JVM.

When Clojure was created?

Clojure was an experimental project that Rich Hickey released in 2007 after prior attempts to make interoperability between Common LISP the language he was using at his job and the greater programming ecosystems JVM and .NET.

The language is being developed as a community-driven project and has evolved a lot since its initial release as one of the most successful functional programming languages in the mainstream.

Why learn Clojure?

Let me try to sell this to you.

Many of the most regarded programmers of all time recommended that every programmer at a certain point should try a LISP dialect.

Richard Stallman, Founder of the Free Software Movement in How I do my computing:

"The most powerful programming language is Lisp. If you don't know Lisp (or its variant, Scheme), you don't know what it means for a programming language to be powerful and elegant."

Eric Steven Raymond Founder of the Open Source Initiative in How to become a hacker:

"LISP is worth learning for a different reason — the profound enlightenment experience you will have when you finally get it. That experience will make you a better programmer for the rest of your days, even if you never actually use LISP itself a lot."

Both founders of the biggest FOSS movements and authors of important open source projects have recommended that every programmer learn LISP for decades and there a many more that also did as Edsger Dijkstra, Bjarne Stroustrup, Larry Wall and Alan Kay.

Clojure is a LISP that runs in JVM one of the most popular runtimes ever created and that empowers tons of the most famous systems out there. Being a JVM language means it can access all the Java ecosystem and thus making it capable to use a very wide range of libraries and tools to make useful things.

Learning Clojure empowers you as a programmer to have the enlightenment of a LISP and the productivity and capacity of Java. If you want to build robust systems with a language with extreme expressiveness Clojure is the right language for you.

How to learn Clojure?

There are many great resources where you can learn Clojure for free.

The first one is Clojure for the Brave and True a free online book written by Daniel Higginbotham that teaches Clojure in a very fun approach and with a lot of visual content that helps to illustrate each lesson.

If you prefer something a little more practical, there is the Clojure Koans a set of Clojure exercises that help to guide you over the language syntax and rules. Each lesson is a unit test written based on a problem you have to resolve using the part of the language being taught.

If you prefer the best of the two worlds is the exercism project, a website that reunites lessons divided into chapters and lessons with community mentors to answer and help in community forums and discussions.

Where I can find help?

The Clojure community is great and there are a lot of places you can reach other clojurians.

There is the official community forum that is hosted on the language website ask.clojure.org for joining the forum you need a GitHub account, after authenticating you can post questions (and answers) in the forum.

If you prefer to use Discord you can join one (or both) the Discljord or Clojurians Discord Servers. Both are great discord communities dedicated to Clojure.

If you're on Twitter you can join the Clojure Community
there you can find a lot of tweets and people related to the language and ask for help or any question you have.

That's all folks! (At least for now)

This is just the beginning of a series of posts I will write while learning Clojure for my new job. I'm eager to start developing great applications with it and hope you continue to follow the upcoming posts.