Programmazione on manuel uberti

Scrappy hearts and Clojure fiddles

manuel.uberti@mailbox.org (Manuel Uberti) — Sat, 21 Sep 2024 00:00:00 +0000

The room is slowly filling up with attendees, organisers and volunteers are moving around to check that everything is where it is supposed to be. I recognise some faces, I spot a couple of speakers. I keep looking around eagerly as if I wanted to take it all in right here right now. This is not my first Clojure conference, and I do hope it will not be the last, but as I sit I feel the same rush of emotions I have only felt once before, back in 2019. It was Heart of Clojure then. It is Heart of Clojure now.

“What does it mean to be here?”

This is a question I would end up asking myself over and over again while in Leuven. While I am back home writing this, I am not sure I have found an answer just yet, so I want to go over the last few days to see if I finally have a reply to that question.

But first, a caveat. If you are looking for a review of the conference or a report on its program, this is not it. I am sure plenty of useful feedback is already popping up around the web and many more will come out along with pictures, videos, and what have you. This writing, however, will mostly be about me and what Heart of Clojure meant to me.

With that out of the way, let’s dig in.

Heart of Clojure was bigger and stronger this time. There were two locations where talks, sessions, workshops and all sort of activities took place. But the conference was bigger and stronger in another, more intimate sense too. The first edition had already been the people’s conference. This time it was as if the organisers had wished not only to up the ante, but to make sure that everyone followed suit. And using two locations for the event had much to do with this.

Since there was always something going on, people were kindly asked to move freely from one place to another. In the rare occasion when nothing was happening, that nothing was just an illusion. Within the locations, in the halls while waiting for the next talk, outside on a bench for a break, or in the street walking to another session, people were literally everywhere, and anywhere a nice chat might start. Even an introverted such as myself could not resist this welcoming energy.

On the other hand, I also avoided many nice occasions to meet a new person or enjoy a friendly conversation. Too shy? Maybe. Too overwhelmed? Indeed. It is not easy for me to take in everything and everyone all at once, my body and my mind simply refuse to comply, I get awkwardly silent and I do not like to be around people when I feel this way. So I needed my breaks, I needed my walks alone around Leuven with my music.¹ I do not know if the organisers had planned for this kind of attendee, but to me it looked like they did. I had time both for myself and the conference, my walks and the people. I realise now that a conference such as this might not be for everyone, especially for the ones who usually like to pile up as many talks as possible, but that is not me. And I am glad Heart of Clojure somehow took care of me.

“What’s your take away from the conference?”

I was asked this question yesterday, on my last day in Leuven and the day after Heart of Clojure had ended. I did not have to think too much to answer. Lu Wilson put it nicely in their outstanding keynote, but they did deliver it directly to me with even more power in a short² conversation one evening. When I write, whatever I write, I have to be comfortable with sharing sides of me, otherwise simply feel OK not doing so. Balancing tiger with rhythm of tortoise, as Angie McMahon sings.

This self-reflexive state of mind became a constant throughout the whole Heart of Clojure not long after the two opening keynotes had ended. My position in the field was shaken multiple times as I was listening to Lu Wilson and Anna Colom. Am I doing the right thing? Am I not questioning enough the work I do? Am I not open enough, aware enough, serious enough? Am I putting my effort and my rather basic set of skills where they should belong? Miranda Kastemaa (a.k.a. pulu)’s live set felt like the much needed relief.

“What does it mean to be here?”

Back to the original question. I sense no single, unequivocal answer to it. Heart of Clojure made me connect with beautiful people, made me conscious of my limited space and time, filled me with smiles and doubts, words and code, prose and poetry. More than once people said that this conference had contributed to pivotal changes in their lives. What if just by setting my foot in Leuven in the past few days something has been set into motion?

Mostly Angie McMahon’s new Light Sides EP and The Ex’s new Great! / The Evidence, but some old favourites like Pinegrove and Fugazi found their way to my ears. Comfort music, so to speak. ↩︎
Because of me, not because of Lu. ↩︎

Heart of Clojure is back

manuel.uberti@mailbox.org (Manuel Uberti) — Wed, 10 Jul 2024 00:00:00 +0000

This will be just a quick announcement.

Heart of Clojure, the biggest Clojure conference in Europe, is happening again, five years after the first edition. I had much fun back in 2019, so I am really excited to have another chance to enjoy it.

You will find me right in Leuven from 18 to 19 September if you want to chat about beautiful topics such as:

Emacs and that’s it
Pet-driven development
À la recherche du REPL perdu
Vegan parenthesis

See you there.

The people’s conference

manuel.uberti@mailbox.org (Manuel Uberti) — Sun, 04 Aug 2019 00:00:00 +0000

I have still to properly unpack my luggage and yet here I am, eager to make sense of the enthusiasm of experiencing Heart of Clojure. I tried my best to pin down on my diary everything that the conference had to offer, because at first I wanted to write a round-up similar to the one I did for Dutch Clojure Days 2018. However, summarising Heart of Clojure seems like an unimaginative exercise. And this is because a summary is by definition a cursory look. Considering what I’ve had the pleasure to enjoy, it doesn’t feel right.

So, what was Heart of Clojure like exactly? After one day and a half in and plenty more to do, I came up with a definition: the people’s conference. Fragments of this definition were already floating around my head as soon as I was in front of Hal5, the incredibly cosy space the Heart of Clojure team set up as the main location for the event. It’s not easy to put it clearly into words, but just take a look at the registration process. You reached a desk, they gave you a badge, you picked the holder of the right colour for you (i.e., green meant you were fine appearing in pictures taken during the conference, pink you were not), you were given pens and markers to write your name on the badge and add whatever customisations you feel like adding to it. Now, go back and count how many you and they there are in the last sentence, and you’ll start getting an idea about the general approach of Heart of Clojure.

The more I think about it, the more I find the effort to make everything safe and nice for the attendees remarkable, especially because it looked like nobody was actually controlling anything. I wasn’t expecting surveillance cameras and SWAT teams, of course, but the simple fact that the responsibility of looking after everyone appeared invisible made for a peaceful environment. And you always had kind and smiling Heart of Clojure’s staff members around ready to help you out or have a chat with you. The results were in plain sight. Everybody looked calm, serene, and even without asking you could tell they were having a great time just being there.

Unsurprisingly, the wide range of topics in the program left me with an impossible amount of thoughts. Teaching programmers to draw, Clojure in fashion, empathy and resilience, inclusiveness and climate change, open source sustainability and fragment shaders, compilers and arcade games. In a two-day span, the selection of talks leveraged topics of such a pervasive power that it was basically impossible not to constantly connect and be moved. With the entertaining work of the hosts and unforgettable MCs Saskia Linder and Bozhidar Batsov there was no such thing as boredom in the air.

At the same time, though, I have to admit I was a bit sceptical about the extra activities. Again, the Heart of Clojure’s masterminds put the people in charge, and so anyone could devise an activity covering the spare time in the evenings, during the long afternoon break on Saturday, or on Sunday morning. Before leaving for Leuven, my overtly paranoid brain asked me: how could they trust everybody like this? What if a too fervid attendee can’t manage it well? Wouldn’t it spoil the fun for the rest of us? It turned out there was too much joyfulness around to be paranoid, a well-deserved lesson for that silly brain of mine. I will never be able to thank the awesome Malwine enough for the sketchnote workshop, and I’ll have to find a way to be at another of her workshops sooner or later.

Probably co-opted by the aforementioned brain, my mind wandered in similar doubts when it came to the lightning talks, but in five minutes Connie silenced both my brain and my mind. I think I’ve held my breath and stood still throughout her entire session, struck in my seat by the genius of an eleven-year old’s crafts. More than anything else, she was the heart at the Heart of Clojure.

I have to stop now, because it’s time to rest and see if I can soothe the intense emotions of the past three days. Did I mention the couple of tears on the My Heart Will Go On karaoke? You cannot play with a sentimental fool like this, people, there are feelings at stake. Come on.

But before turning off the lights:

Thank you Arne and thank you Martin: you conceived the impossible and made it happen. Please make it happen again.

Thank you Heart of Clojure’s program committee and reviewers: Arne and Martin couldn’t have made it without you.

Thank you speakers: singling out one of you would be unfair and completely pointless. You all inspired me, in one way or the other.

Thank you Saskia: you taught me the beauty of reaching out, and I will treasure the words on emotion management for a long while.

Thank you Bozhidar: no, not for just CIDER this time. For everything, including the unparalleled dancing skills.

Thank you Carlo, Davide, Fabrizio, and Kleopatra: I’m still not sure of how you did it, but you made me forget sociability is an issue for me. For a while, at least.

Thank you Marco and thank you 7bridges: I just couldn’t have managed it by myself.

Thank you James Cameron: yes, I still cry with that film, why are you doing this to me?

Getting ready for Heart of Clojure

manuel.uberti@mailbox.org (Manuel Uberti) — Wed, 03 Jul 2019 00:00:00 +0000

Quick announcement.

I’m going to be in Leuven from 1 to 3 August, ready to enjoy Heart of Clojure.

I’ve been following the development of the conference since the first announcements, and the awesome team behind it has been keeping me really excited along the way. The incredible variety of topics in the program is already enough to skyrocket my expectations.

As I did with Dutch Clojure Days last year, I’ll take notes diligently and report my experience here as soon as I get back.

If you fancy wise Clojure chats or wild Emacs ramblings, get in touch. There is a dedicated #heartofclojure channel on Clojurians which I’ve already joined, or you can always rely on good old emails.

See you there, Clojurists!

Moving to deps.edn and shadow-cljs

manuel.uberti@mailbox.org (Manuel Uberti) — Wed, 14 Nov 2018 00:00:00 +0000

Last summer I moved boodle from Figwheel to Figwheel Main. I was pretty satisfied with this setup, but the rise of shadow-cljs in the Clojure community has been tickling my curiosity over and over again. While configuring shadow-cljs I took the chance to set lein aside and finally explore clj and deps.edn, another thing on my to-do list that has been waiting for me for some time.

Let’s start with deps.edn:

{:deps
 {
  ;; … Clojure dependencies …
 }

 :paths ["src/clj" "resources"]

 :aliases {:run {:main-opts ["-m" "boodle.core"]}
           :test {:extra-paths ["test/clj"]
                  :extra-deps {lambdaisland/kaocha {:mvn/version "0.0-266"}}}
           :outdated {:extra-deps {olical/depot {:mvn/version "1.4.0"}}
                      :main-opts ["-m" "depot.outdated.main"]}}}

One thing worth of notice here is :paths. I included the resources directory in it because I serve it via compojure/http-kit and that’s where I put the static assets used in my main index page. This solution works when I run mount.core/start via REPL and when I use the :run alias from the command line.

Speaking of aliases, they are invaluable. With :run I can use clj -A:run instead of lein run, and with clj -A:outdated -a outdated I can easily check for outdated dependencies in my deps.edn thanks to depot. Unit tests are now handled by Kaocha, and as per its instructions I have a bin/kaocha file which picks up the :test alias and runs all my tests.

I love the simplicity of deps.edn, it feels like a de-cluttered project.clj.

Configuring shadow-cljs was a bit more complicated. It took me a while to understand how to properly integrate it with CIDER. However, the manual is great and the fine people on Slack’s #shadow-cljs (thanks Ryan Haywood and Thomas Heller!) made it all nice and smooth.

This is my shadow-cljs.edn:

{:source-paths ["src/cljs"]
 :nrepl {:port 8777
         :middleware [refactor-nrepl.middleware/wrap-refactor]}
 :dependencies [
                 ;; … ClojureScript dependencies …
               ]
 :builds {:boodle {:target :browser
                   :output-dir "resources/public/js"
                   :asset-path "/js"
                   :modules {:main {:entries [boodle.core]}}}}}

Basic setup, straight from the manual pages. Notice that :output-dir refers to the same resources directory configured in deps.edn. This tells shadow-cljs to place the build output exactly where I need.

The other important change is in the CLJS libraries I use. shadow-cljs does not support CLJSJS, so I had to install pikaday and moment via yarn.

$ yarn add pikaday moment

Since boodle relies on re-frame, I had to install three other libraries to make shadow-cljs build my code happily:

$ yarn add react react-dom create-react-class

In the namespace where I use them, the :require had to be changed:

(:require ;; … other requires …
          ["react-dom" :refer [findDOMNode]]
          ["pikaday" :as pikaday])

And the code had to be adapted:

(let [default-opts {:field (findDOMNode this)
                    ;; … other options …
                   }
      instance (pikaday. opts)]
    ;; … other ClojureScript code …
)

However, a project setup is not ready unless I can work on it via Emacs. These are the steps I made to have a working CLJ/CLJS development environment. When this issue will be fixed some of it may become unnecessary.

First, I added a couple of dependencies in shadow-cljs.edn:

:dependencies [;; … other dependencies …
               [cider/cider-nrepl "0.18.0"]
               [refactor-nrepl "2.4.0"]]

Then I removed everything Figwheel Main related from the .dir-locals.el file located in the root directory of boodle:

((nil
  (cider-default-cljs-repl . shadow-select)
  (cider-pprint-fn . zprint)
  (cider-preferred-build-tool . clojure-cli)
  (cider-known-endpoints . (("hathaway" "localhost" "8777")))
  (cider-ns-refresh-after-fn . "mount.core/start")
  (cider-ns-refresh-before-fn . "mount.core/stop"))
 (emacs-lisp-mode
  (flycheck-disabled-checkers . "emacs-lisp-checkdoc")))

I ran cider-jack-in-clj to have a CLJ REPL and check I didn’t break something on the Clojure side of boodle.

From a terminal, I used shadow-cljs watch boodle to have shadow-cljs build boodle and offer me a nice nREPL server listening on port 8777, the one I specified in shadow-cljs.edn.

Back in CIDER, cider-connect-cljs brought up a REPL connected to shadow-cljs nREPL server, and let me select the build I want it operating on (default is dev, I just typed in boodle). Connecting to boodle via the browser finalized the connection between my code and the CLJS environment.

A great journey. Once again, boodle proved fertile ground to understand the Clojure ecosystem and play with it to learn something new. If you want more details, the project is on my SourceHut.

Handy sudoing in Fish

manuel.uberti@mailbox.org (Manuel Uberti) — Sat, 27 Oct 2018 00:00:00 +0000

It’s been more than a year and a half now since I moved from Zsh to Fish, and I am still amazed by how smooth and simple it made my everyday workflow.

One little trick I’ve been taking with me from my Bash days is aliasing sudo to _. There are a lot of commands I need to run via sudo, and typing one character instead of four makes it obviously quicker. But what if I already started to write a command which needs proper privileges and forgotten about that precious sudo?

Lukas Stabe fixed it for me, years ago. First, let’s add his prepend_command to ~/.config/fish/functions/prepend_command.fish:

function prepend_command
    set -l prepend $argv[1]
    if test -z "$prepend"
        echo "prepend_command needs one argument."
        return 1
    end

    set -l cmd (commandline)
    if test -z "$cmd"
        commandline -r $history[1]
    end

    set -l old_cursor (commandline -C)
    commandline -C 0
    commandline -i "$prepend "
    commandline -C (math $old_cursor + (echo $prepend | wc -c))
end

Then, it’s only a matter of adding a key binding to ~/.config/fish/functions/fish_user_key_bindings.fish:

function fish_user_key_bindings
    fish_default_key_bindings

    # Prepend sudo with C-s
    bind \cs 'prepend_command sudo'
end

Now hitting Ctrl-s anywhere in the command I am typing immediately adds sudo at the beginning of the line.

prepend_command comes with the benefit of mimicking the sudo plugin of Oh My Zsh. Fish doesn’t support history expansion, but sometimes I just press Enter before remembering to hit Ctrl-s, and that’s where I’d love some history expansion. I can hit Ctrl-s right after the malevolent Enter, and have my previous command with sudo automatically prepended ready to go.

If you are accustomed to the Zsh key binding, you can have it in Fish too:

# Re-run previous command with sudo using ESC-ESC
bind \e\e 'prepend_command sudo'

Time savers, believe you me.

Moving to Figwheel Main

manuel.uberti@mailbox.org (Manuel Uberti) — Fri, 03 Aug 2018 00:00:00 +0000

If you are a Clojure/ClojureScript programmer, you know Bruce Hauman and chances are he is one of your personal heroes. If you are not already in love with him, just watch his awesome talk on Figwheel and join the club.

Figwheel changed the way I work with ClojureScript with prompt live code reloading and REPL interaction, greatly enhancing my web-application development.

Bruce pushed Figwheel further when he unveiled Figwheel Main, a complete re-write of Figwheel compatible both with Leiningen and the new Clojure CLI tools. I have resisted the urge to try it for a while, but then I remembered I have my own battleground for experimenting and learning Clojure wonders: boodle.

I have decided to stay with Leiningen for now, but I may move to a full clj and deps.edn setup in the future.

The first thing to change in order to accommodate Figwheel Main is my project.clj. A new version of ClojureScript is necessary:

:dependencies
[ ;; … more dependencies …
  [org.clojure/clojurescript "1.10.312"]
  ;; … more dependencies …
]

Then, new values for :source-paths and :resource-paths:

:source-paths ["src/clj" "src/cljs"]
:resource-paths ["target" "resources"]

As the Figwheel Main README suggests, let’s add a couple of useful aliases:

:aliases
  {"fig" ["trampoline" "run" "-m" "figwheel.main"]
   "build" ["trampoline" "run" "-m" "figwheel.main" "-b" "boodle"]}

And the actual Figwheel Main dependencies:

:profiles
  {:dev
   {:dependencies [[binaryage/devtools "0.9.10"]
                   [cider/piggieback "0.3.8"]
                   [com.bhauman/figwheel-main "0.1.4"]
                   [com.bhauman/rebel-readline-cljs "0.1.4"]
                   [figwheel-sidecar "0.5.16"]]
    :repl-options {:nrepl-middleware [cider.piggieback/wrap-cljs-repl]}}}

I still want lein-cljsbuild for a production-ready build, so I can just simplify the :build map:

:cljsbuild
  {:builds
   {:min
    {:source-paths ["src/cljs"]
     :compiler {:main boodle.core
                :output-to "target/public/cljs-out/boodle-main.js"
                :asset-path "target/public/cljs-out/boodle"
                :optimizations :simple
                :pretty-print false}}}}

With project.clj ready, I move to boodle.cljs.edn. This is what Figwheel Main needs to know the entry point of my application:

{:main boodle.core}

Following the instructions, I also customize some options in figwheel-main.edn:

{:watch-dirs ["src/cljs"]
 :css-dirs ["resources/public/css"]
 :open-url false}

Refer to the documentation to see what other options are available.

The last change I have to make is in my index page. Figwheel Main outputs the compiled JavaScript file in target/public/cljs-out/boodle-main.js, so I only need to modify the reference to it:

(hiccup/include-js "cljs-out/boodle-main.js")

Now it’s enough to run lein build and lein run from the project root directory.

However, since CIDER is a vital component of my daily workflow, I set it up in .dir-locals.el to run figwheel-main on C-c C-x j m. This will automatically launch a Clojure REPL and a ClojureScript REPL when CIDER starts:

(cider-default-cljs-repl . figwheel-main)
(cider-figwheel-main-default-options . ":boodle")

That’s it. Welcome Figwheel Main and, of course, a huge “thank you!” to Bruce Hauman for the superb work.

If you want to know more, boodle is available on SourceHut.

Re-implementing boodle database layer

manuel.uberti@mailbox.org (Manuel Uberti) — Sun, 15 Jul 2018 00:00:00 +0000

When I wrote boodle, I didn’t think the database layer thoroughly. The model was simple enough to figure out: one namespace for each table. However, I stuck the queries at the top of these namespaces, using plain strings to compose them.

A working solution, yes, but far from being optimal. Let’s be honest: it’s just plain ugly and prone to error. White spaces, characters to escapes. Not a mess, but neither a smooth ride.

At 7bridges I recently had the chance to play with Honey SQL. At first I wrongly mistook it for syntactic sugar. A DSL on top of SQL? The horrors of ORM sprang to mind in a rush of anxiety, but I set aside my fears and gave it a chance anyway.

It took me ten minutes to fall in love with honeysql. And turning to boodle for a proper refactoring was the following thought.

A quick example of how prettier queries are now:

(defn select-aims-with-transactions
  []
  (-> (hh/select :a.id [:a.name :aim] :a.target :t.amount)
      (hh/from [:transactions :t])
      (hh/right-join [:aims :a] [:= :a.id :t.id_aim])
      (hh/where [:= :a.achieved false])
      hc/build
      db/query))

No strings, no white spaces, no escaping characters and quoting values. Heaven.

honeysql is also extensible, which makes it simple to add support for operators.

(:require [honeysql.format :as fmt])

;; … other code …

(defmethod fmt/fn-handler "ilike" [_ col qstr]
  (str (fmt/to-sql col) " ilike " (fmt/to-sql qstr)))

During the refactoring process, I noticed something else that needed a better solution: dates.

I was relying on PostgreSQL TO_DATE to format my dates in the queries. honeysql is database-agnostic, so it pushed me to look for a better option.

(:require [java-time :as jt])

;; … other code …

(extend-protocol jdbc/IResultSetReadColumn
  Date
  (result-set-read-column [v _ _]
    (-> v
        jt/local-date
        ud/format-date))

  Timestamp
  (result-set-read-column [v _ _]
    (-> v
        jt/local-date
        ud/format-date)))
        
(extend-protocol jdbc/ISQLValue
  java.time.LocalDateTime
  (sql-value [v] (jt/sql-timestamp v))
  java.time.LocalDate
  (sql-value [v] (jt/sql-timestamp v)))
        
;; … other code …

format-date is just a utility function:

(:require [java-time :as jt])

;; … other code …

(defn format-date
  "Return `date` in dd/MM/yyyy format."
  [date]
  (jt/format "dd/MM/yyyy" date))

If you have any experience with Java, you know dealing with dates and times had not been a piece of cake before Java 8. I briefly mentioned LocalDate when reporting on my experience with Java 8.

Now that I am working with Clojure, dates and times strike back. And thanks to Vadim Platonov, I can safely use Java 8 Date-Time API with clojure.java-time.

Through the lands of static typing

manuel.uberti@mailbox.org (Manuel Uberti) — Thu, 14 Jun 2018 00:00:00 +0000

Last December I started my own trip towards Haskell, jumping in with much enthusiasm and curiosity. The Haskell Book has been the perfect companion, and since chapter 12 just ended I would like to write about my progress with this wonderful programming language.

A new house and everything that comes with it gleefully slowed me down on my studies, but Haskell has never left me alone during these months. The Haskell Book is really excellent at guiding me one concept at a time, and I am finally beginning to understand the benefits of static typing.

Coming from Clojure made the first chapters pretty straightforward. This is not to Haskell detriment, of course. It just felt good to be able to reason about lists, recursions, and folds without too much of an effort. Types and typeclasses is where the real fun began, and I can say so far so good. Specifying the type of every function, even when it can be safely omitted, is simple and useful, and it is helping me get a better grasp of the power of static typing.

I must admit writing datatypes scared me at first. Years of Java developing spoiled me on classes and objects, and I swear those datatypes seemed classes to my object-oriented eyes. Shame on me. Kinds and higher-kinded types deserve further study, though. I can write my on datatypes now, albeit trivial ones, but types of type constructors deserve deeper inquiries.

There is one more thing I am really enjoying: the syntax. I know you would expect otherwise from a Clojurist, but Haskell syntax is just lovely. It’s maths all over again, and I am in love with it just as much as I love my parenthesis.

That’s it for now. Monads, here I come.

Dutch Clojure Days 2018 round-up

manuel.uberti@mailbox.org (Manuel Uberti) — Mon, 23 Apr 2018 00:00:00 +0000

As you may recall, I had enthusiastic expectations and resolutions for Dutch Clojure Days. My first Clojure-only conference, my first proper face-to-face with the community. How could I not be excited?

On Saturday 21st at 8:30 am sharp we were at the TQ building reception, greeted by Carlo Sciolla, one of the organisers. A couple of words on the venue: a simple but elegant building, close to Dam Square and right in front of a fascinating flower market. The conference happened on the fourth floor, with a balcony to enjoy the outstanding view on the city, and food and drinks for everybody. My first, huge “thank you, DCD!” goes to the vegetarian option which was palatable for a vegan, but let’s keep the cheering and the hand-clapping for the end.

Eleven speakers were waiting for us. Vijay Kiran set the stage and the playful mood of the day, leaving soon room to Alex Yakushev. “Embrace the JVM” was a talk to treasure. Observability, performance profiling, memory inspection. I am by no means a JVM expert, however the tools Alex showed us will definitely help me get a better understanding of the machinery behind Clojure.

Simon Belak was up next talking about transducers and statistical analysis. This was probably the hardest one for me. I haven’t found a way to appreciate the value of transducers yet, and statistical analysis is not my strongest skill. But I still appreciated the concept of sketch algorithms and I will hunt histograms pretty soon.

Srihari Sriraman with “Practical Generative Testing Patterns” blew my mind and, if you fancy ratings and such, was the highlight of the day. We all know test.check is good, but the approach of Srihari to automation, seeding relevant data and testing plausible behaviours left me eager to grab my keyboard and implement something similar.

After lunch we were treated to one more talk before the lightning sessions. Wilker Lúcio explained the beauty and easy-of-use of GraphQL, an interesting alternative to REST for better APIs.

The lightning talks kicked off with some magical REPL-debugging from Valentin Waeselynck. His scope-capture looked promising, and I can only hope for an integration with CIDER. Dr Roland Kay reminded us of the usefulness of clojure.spec, although if I had to base my opinion of clojure.spec on his talk, it roughly looked like the type-system Clojure is missing. No trolling intended. Thomas van der Veen hit the MQTT broker pedal, mixing Java and Clojure, but I am still not sure I got the purpose of the experiment aside from the sake of learning. Ray McDermott closed the lightning sessions with an amazing browser-driven, multi-user REPL he is devising which can make live pair-programming scattered around the world a breeze.

The last three talks reflected experiences of using Clojure for business. Josh Glover, Philip Mates and Pierre-Yves Ritschard shared with us the journeys of their companies and projects and how designing, developing, and testing have only improved since their move to our beloved language.

Drinks followed before a bit of REPL-driven comedy courtesy of Ray McDermott. Suffice it to say we sang the Clojure version of Bowie’s “Rebel Rebel” aptly entitled “REPL REPL”. If you weren’t there, well, you don’t know what you missed.

Dutch Clojure Days left me with the impression that the Clojure community is alive and hard-working, and its heart is in the right place. Ideas flourish, projects boom, boundaries get stretched. We can only be thankful to the DCD staff for being able to set up such a pleasant event, asking us only to join them to share our passion.

Getting ready for Dutch Clojure Days

manuel.uberti@mailbox.org (Manuel Uberti) — Tue, 23 Jan 2018 00:00:00 +0000

As a functional programming jock, I have a confession to make: I have never been to a Clojure conference. There was a bit of Clojure in the now defunct LambdaCon, but the talks there were not as riveting as the ones I caught on YouTube from the likes of Clojure/conj, clojuTRE and Clojure/west.

No need to sound depressing, though. Thanks to 7bridges, I will happily attend Dutch Clojure Days 2018 on April 21st. As much as my enthusiasm is hard to contain, I plan to fulfil a bunch of resolutions without losing myself in total exuberance.

Learn something new

I know the list of speakers is not ready yet, but surely something new and good is waiting for me. This is usually what happens with the talks once the conference I missed makes the videos available, therefore I am pretty confident there is going to be a lot of food for my brain.

Learn something better

As far as my Clojure projects go, there is still plenty I have to master. Transducers? Spec? Design patterns? Performance? UX? Hit me, please. The amateur in me is eager to become a Clojure programmer worth his salt.

Join the community

Last but not least, I will set aside my never-ending fight with sociability and enjoy the Clojure community for real. I’ll be in Amsterdam from Friday afternoon to Sunday evening, so you will have enough time to join me in some healthy discussions about your favourite programming language. Or Emacs, if you fancy wild topics.

A year of functional programming

manuel.uberti@mailbox.org (Manuel Uberti) — Thu, 21 Dec 2017 00:00:00 +0000

First things first: the title is a lie.

If you happen to be one of my passionate readers, you may recall I started working with Clojure on April 1. So yes, not every month of the year has been devoted to functional programming. I just needed something bold to pull you in, sorry.

Now, how does it feel having worked with Clojure for ~~almost~~ a year?

Here at 7bridges we had our fair share of projects. The open source ones are just a selected few: clj-odbp, a driver for OrientDB binary protocol; carter, an SPA to show how our driver works; remys, a little tool to interact with MySQL databases via REST APIs. I also had the chance to play with ArangoDB recently, and there were no problems building a sample project to understand its APIs.

At home, boodle was born to strengthen my ever-growing knowledge and do something useful for the family.

When I started in the new office, the switch from professional Java to professional Clojure was a bit overwhelming. New libraries, new tools, new patterns, new ways of solving the same old problems, new problems to approach with a totally different mindset. It all seemed too much.

Then, something clicked.

Having the same language on both client- and server-side helped me figure out the matters at hand with a set of ideas I could easily reuse. Once I understood the problem, I could look for the steps to solve it. Each step required a data structure and the function to handle this data structure. The first time I used reduce-kv because it was the most natural choice left a great smile on my face.

There is still much to learn, though. Due to lack of experience with JavaScript, my ClojureScript-fu needs to improve. I have come to appreciate unit testing, but it’s time to put this love at work on my .cljs files too. I also definitely want to know more about Clojure web applications security and performances.

2017 has been a great year to be a functional programmer. My recent liaison with Haskell is directing me more and more on my way. The functional programming way.

Learning Haskell

manuel.uberti@mailbox.org (Manuel Uberti) — Fri, 08 Dec 2017 00:00:00 +0000

Since my first baby steps in the world of Functional Programming, Haskell has been there. Like the enchanting music of a Siren, it has been luring me with promises of a new set of skills and a better understanding of the lambda calculus.

I refused to oblige at first. A bit of Scheme and my eventual move to Clojure occupied my mind and my daily activities. Truth be told, the odious warfare between dynamic types troopers and static types zealots didn’t help steering my enthusiasm towards Haskell.

Still, my curiosity is stoic and hard to kill and the Haskell Siren was becoming too tempting to resist any further. The Pragmatic Programmer in me knew it was the right thing to do. My knowledge portfolio is always reaching out for something new.

My journey began with the much praised Programming in Haskell. I kept track of the exercises only to soon discover this wasn’t the right book for me. A bit too terse and schematic, I needed something that could ease me in in a different way. I needed more focus on the basics, the roots of the language.

As I usually do, I sought help online. I don’t know many Haskell developers, but I know there are crazy guys in the Emacs community. Steve Purcell was kind and patient enough to introduce me to Haskell Programming From First Principles.

This is a huge book (nearly 1300 pages), but it just took the authors’ prefaces to hook me. Julie Moronuki words in particular resonated heavily with me. Unlike Julie I have experience in programming, but I felt exactly like her when it comes to approaching Haskell teaching materials.

So here I am, armed with Stack and Intero and ready to abandon myself to the depths and wonders of static typing and pure functional programming. I will track my progress and maybe report back here. I already have a project in mind, but my Haskell needs to get really good before starting any serious work.

May the lambda be with me.

boodle

manuel.uberti@mailbox.org (Manuel Uberti) — Sun, 26 Nov 2017 00:00:00 +0000

The usefulness of in-house accounting has become evident only in recent years. On different occasions, my wife and I discussed a solution for keeping track of expenses and available budget for short- and long-term goals. Simply put: the bank statement was not enough any more.

In the past we relied on ledger, knowing too well the power of plain text. For a while we succeeded in our money management, because ledger is really that good. However, soon we started thinking about savings and goals, about a custom user interface to have a better understanding of our financial situation.

Naturally, I decided to use some of the experience I gained at work to develop our own application. I wanted a simple single-page application that would enable us to:

track expenses
query expenses to get reports
track short- and long-term goals

boodle (a synonym of money, in case you are wondering) has the following architecture:

client: re-frame
server: ring on top of HTTP kit
database: PostgreSQL

I have set up bidi for client-side routing, compojure for server-side routing and compojure-api to connect client and server via pleasant APIs.

Thanks to mount I have three main components that I can start and stop to make development and debugging easier: application configuration, database and HTTP server.

I decided to give dire a try, appreciating the separation between logic and error handling. I also took the chance to couple clojure.test with test.check, for some basic property-based testing, and lein-eftest to have fast and pretty test results.

The setup is completed by the continuous integration offered by Travis CI and Deps Versions to identify outdated dependencies. Everything is available on SourceHut, if you want to dig deeper into the details.

boodle is currently deployed on my home server, and in the last months it has proved to be a reliable tool. It also deepened my love for Clojure and ClojureScript. Long forgotten are the days where separation of concerns, both client- and server-side, seemed impossible and destined to fail.

Daily Clojure workflow

manuel.uberti@mailbox.org (Manuel Uberti) — Sat, 29 Apr 2017 00:00:00 +0000

It’s already been a month since I started my new job. All is going well and just as expected, and it’s been interesting to see how my carefully tuned Emacs configuration dealt with everyday Clojure programming.

Truth be told, I’ve never used Emacs consistently for work. Before Clojure I mainly did Java and Emacs support for Java is not as good as what it offers for other programming languages. Yes, I kept Emacs around for other stuff, but it would be a dull lie to tell I was proudly using Emacs all day in the office.

Anyway, Clojure is the new kid in town now so it’s Emacs all the way. The obvious first choice is CIDER and I genuinely don’t have enough words to say how wonderful it is. I couple it with clj-refactor and Smartparens to get the most out of my coding experience.

I especially love how CIDER enables me to switch easily between Clojure and ClojureScript, with two REPLs ready to go and documentation just under my fingertips. clj-refactor enriches exploratory development with hot reloading of dependencies and handy change of missing requires.

Then there is Projectile. Even on small Clojure projects we are using to test available libraries there are plenty of files around. Mickey Petersen talks about tempo when it comes to using Emacs. Projectile guarantees you don’t lose your tempo while working on projects of different sizes.

What else? I don’t think Magit needs my over enthusiastic words. Ivy is proving to be the right tool at the right time, with Swiper ever so helpful. And now I am only waiting for the day we will need proper documents to bring out the almighty AUCTeX.

In the immortal words of Bozhidar Batsov:

Emacs is power.
Emacs is magic.
Emacs is fun.
Emacs is forever.

Clojure it is

manuel.uberti@mailbox.org (Manuel Uberti) — Sun, 12 Mar 2017 00:00:00 +0000

Last Friday I finally told my boss that I am going to leave his company for another job.

It’s not the first time in my working life that I want to move to greener pastures. For different reasons I changed jobs quite a lot in the last 10 years. However, this is the first time that I made my decision based on the programming language being used in the office.

As much as I had fun working with Java 8, in the last months there has been little of it. Bouncing back and forth between Java 7 and PHP 5.6 for legacy code maintenance is not exactly my idea of fun.

Both Clojure and functional programming changed the way I think about solving problems with code. I often found myself thinking outside the boundaries of OOP, craving for pure and higher-order functions, all of which are just out of reach in the aforementioned versions of Java and PHP.

The adoption of Clojure by Italian software houses is still close to none. It’s been a while since I started looking for a job with Clojure, but until now the only opportunities I found required moving to another country. I even tried to convince myself I was willing to pack my bags again, but family comes first and deep in my heart I knew I couldn’t ask my wife to leave everything behind.

Imagine my shock when I heard that 7bridges was hiring. Marco Dalla Stella, CTO and Co–founder of the company, is the man who guided me through my first steps with Clojure. It was him, 2 years ago, who pointed me to Programming Clojure and The Joy of Clojure. It was him who joined me for a trip to Bologna where LambdaCon happened. He’s also an Emacs user, which means he must be one of the good guys.

And now I can’t wait to start working with Clojure for real. I celebrated the beginning of this new adventure with a new Dell XPS 13 which will surely be perfect for what I have in mind.

Eventually, Clojure it is.

Reflecting on my Java 8 experience

manuel.uberti@mailbox.org (Manuel Uberti) — Sat, 22 Oct 2016 00:00:00 +0000

After four months of being back to Java for work, I would like to share my impressions about Java 8. Mind you, this is my first time with Java 8 on a project, so I do not consider myself an expert on the subject. What I can promptly say, though, is this: I have never had so much fun using Java before.

One of the reasons I have been partly away from Java since 2012 is that I have been more and more dragged towards functional programming (FP from now on). It all started with my fascination with Emacs and Emacs Lisp, then Scheme and Clojure hit my curiosity harder. Recently, Scala has been insinuating in my brain. You can already see a pattern here, can’t you? FP stole my heart.

I knew Java 8 stormed the object-oriented (OO from now on) community with plenty of FP material, but it took a new, big project and the brilliant Java 8 In Action to convince me I could go more functional than I was hoping for.

The team I work with comes from a purely OO mindset, so I was a bit reluctant to introduce FP ideas and solutions. I jumped right in the middle of the development, with a large codebase already there before the time of my arrival. The only hint of Java 8 I found was a single use of forEach with a lambda expression in it.

I then began using lambda expressions, streams and the Optional class in utility classes and enumerators I could quickly write unit tests for. The benefits were immediately evident: my code was getting clearer and concise, and programming in a declarative fashion made it easier to read and understand. My aim exactly.

To the rest of the team it all looked like syntactic sugar at first. One team member advised me to spread lambdas as little as possible. Fortunately, he soon came to appreciate my efforts and suggested not to be afraid of refactoring code smells if I felt like it.

As much as I like working with lambdas and streams, not to mention LocalDate, the Java 8 feature that really shines in our codebase is CompletableFuture.

We have a bunch of operations that need to be asynchronous. Basically, they collect data from different web services to then build a composite response for the client. The first implementation of asynchronous operations was using Future and Callable. It was working fine, but the logic behind error handling was a mess of try {…} catch {…} copied and pasted in different places. Moreover, the Callable classes were just switch statements bound to get bigger and bigger.

CompletableFuture made everything better. I wrapped each asynchronous operation in a CompletableFuture, removing the unneeded Callable. It is not hard now to comprehend the logic behind the algorithm, because it is definitely simpler than before. Error handling is just a matter of dealing with three possible exceptions.

Java 8 is neither Scala nor Clojure, but as a functional programmer wannabe it makes me appreciate Java again.