The state of editor tooling for programming languages has seen great change in recent memory thanks to Microsoft's specification of a [Language Server Protocol]( https://microsoft.github.io/language-server-protocol/overview) (LSP). While some editors bundle LSP out of the box, making it a breeze to get up and running, others take a little more tweaking. In a series of posts, I will detail the state of LSP editor tooling in Reason / OCaml, as well as how to get set up quickly in a variety of e...| anmonteiro
Lumo has shipped with experimental support for [compiling ClojureScript projects](2017/02/compiling-clojurescript-projects-without-the-jvm) entirely without the JVM since the beginning of 2017. Starting with the newly released version, the Lumo build API has been greatly enhanced and much more stable! Read on for a rundown of the state of ClojureScript compilation in Lumo.| anmonteiro
_I used [Reason](https://reasonml.github.io/) and [React](https://reasonml.github.io/reason-react/) to build a simple example app: [ReKeys](https://anmonteiro.com/rekeys/). Here's what I learned._| anmonteiro
This post reflects on Lumo's growth almost 6 months after its announcement, shares the project's goals and communicates what you can do to help Lumo grow into and even more full-featured ClojureScript environment. Read on!| anmonteiro
Node.js module support has been greatly enhanced in the upcoming release of the ClojureScript compiler. This post explains how to seamlessly require Node.js packages from any ClojureScript namespace. Read on!| anmonteiro
I have dreamed about being able to compile a ClojureScript project without installing Java ever since coming to know that [ClojureScript can compile itself](http://swannodette.github.io/2015/07/29/clojurescript-17). While projects like [Planck](https://github.com/mfikes/planck) and [Lumo](2016/11/the-fastest-clojure-repl-in-the-world) can either run arbitrary ClojureScript forms at the REPL or run ClojureScript scripts, none have actually supported flat out compiling an entire ClojureScript p...| anmonteiro
One common complaint of Clojure REPLs is their [startup time](http://puredanger.github.io/tech.puredanger.com/2013/12/01/clj-problems/). Although that complaint is often somewhat unfounded (and related to tooling), it still takes the bare Clojure JAR about 1 second to start on new hardware. [Planck](http://planck-repl.org) — through bootstrapped ClojureScript, and owing to the small latency exhibited by JavaScript VMs — managed to improve the time that it takes to bootstrap a Clojure(Scri...| anmonteiro
The next version of the ClojureScript compiler adds support for using `require` outside of the `ns` form. Owing to ClojureScript's compilation model, however, there exist subtle differences with respect to the behavior that Clojure provides. Read on to learn more.| anmonteiro
The phrase "incremental rendering" is frequently thrown around in the context of Om Next's design. This post is an attempt to clarify what the concept of incremental rendering is all about, what it does for your Om Next applications and how you can take advantage of its properties.| anmonteiro
Just recently, Om Next added support for server-side rendering. This is a very exciting addition, which greatly improves Om's fullstack story, making it possible to add considerable performance improvements to your app's initial render.| anmonteiro
On the 6th of September, I had the pleasure to speak at [Full Stack Fest 2016](https://2016.fullstackfest.com/) in Barcelona. The talk has been recorded and you can find a link to the video below.| anmonteiro
A small number of changes to Om Next makes it possible to use it from self-hosted ClojureScript environments. Read on!| anmonteiro
There exist a [number of differences](https://github.com/clojure/clojurescript/wiki/Differences-from-Clojure) between Clojure and ClojureScript, especially concerning [namespace declarations](https://github.com/clojure/clojurescript/wiki/Differences-from-Clojure#namespaces) and `require` specifications. Some of these differences have recently been addressed with the introduction of [Clojure namespace aliasing](http://blog.fikesfarm.com/posts/2016-07-03-clojurescript-clojure-namespace-aliasing...| anmonteiro
There are several different options to implement routing in an Om Next application. However, any one of those approaches is not straightforward to accomplish, and often requires more time than one would like to get right. Until now.| anmonteiro
At the end of April, I gave a talk about Om Next at [Craft Conf](http://craft-conf.com/) in Budapest. The talk was recorded and the link is below.| anmonteiro
Although a standard routing solution is an orthogonal concern to Om Next's design and, at the time of this writing, there is still [ongoing development](https://github.com/omcljs/om/wiki/Routing-Support) with the objective of introducing simpler routing hooks, there are already several ways in which one can add proper route navigation to an Om Next app. This post aims to decrease the general community confusion around this topic by introducing a variety of different approaches that can be use...| anmonteiro
In a recent post, I've put together a checklist covering the steps involved in [writing reloadable Om Next code](2016/01/writing-om-next-reloadable-code-a-checklist). If you are trying to use them in your devcards, however, you might find that current [Devcards helpers for Om Next](https://github.com/bhauman/devcards/pull/85) are still lacking full support for a pleasant, out-of-the-box reloadable experience, even when sticking to every recommendation in that list. Enter [\`devcards-om-next\`...| anmonteiro
It didn't take long since [Figwheel](https://github.com/bhauman/lein-figwheel) came into our ClojureScript environments for it to become a crucial part of our development workflow. Its code hot loading magic provides the basis for an easy, enjoyable [interactive programming](https://en.wikipedia.org/wiki/Interactive_programming) experience. The rest — writing code that can be repeatedly evaluated without disturbing our running program's state — is up to us. In this post I will go through ...| anmonteiro
This is part two of a series of posts that aim to demonstrate how to build classical Software Engineering object recursion patterns in Om Next. In the [previous post](2016/01/exploration-patterns-om-next-part-1), we explored the Om Next constructs of the Composite. This time around we will use the [Decorator](https://en.wikipedia.org/wiki/Decorator_pattern) design pattern to build a simple component hierarchy that provides runtime extensibility.| anmonteiro
The recent [landing of recursive union queries](https://github.com/omcljs/om/pull/562) in Om Next allows for defining recursive, heterogeneous data in a simple, expressive way. In a series of posts, I will explore how this conjugates with well-known Software Engineering structural design patterns that are based on object recursion. In this part 1 we will put together a simple component hierarchy that uses the [Composite](https://en.wikipedia.org/wiki/Composite_pattern) design pattern. Let's d...| anmonteiro
As more people start tinkering with Om Next, similar questions keep popping up increasingly often. While this is a natural thing given any new learning efforts, there can never be too many resources when we start learning something new. This write-up is an attempt to get people up and running with Om Next's query syntax by providing comprehensive examples and a quick syntax reference for the future.| anmonteiro
It has been a while since Martin Klepsch posted his [Om Next reading list](http://www.martinklepsch.org/posts/om-next-reading-list.html). If you're learning Om Next or planning to, there are a bunch more excellent resources that have recently appeared, and this post compiles a list of some of them.| anmonteiro
For sometime around last year, I had been toying with a simple [isitup.org](https://isitup.org/) API client and command line tool in Clojure. Just until a few days ago, it was just sitting in [my GitHub page](https://github.com/anmonteiro). Until I decided to put it out there.| anmonteiro
Ever wanted to host pictures or other files on GitHub without storing them in a repository? Here's a simple hack which allows us to host our files directly on GitHub's cloud.| anmonteiro
Most Clojurescript apps that rely on browser routing are wired in some manner to either the Google Closure Library's [HTML5 History](https://closure-library.googlecode.com/git-history/docs/class_goog_history_Html5History.html) module or - in an increasingly lower number of cases - the [History](https://closure-library.googlecode.com/git-history/docs/class_goog_History.html) module. While both [`pushState`](https://developer.mozilla.org/en-US/docs/Web/API/History_API)- and [fragment](https://e...| anmonteiro
Configuration or environment variables are really useful whether you want to externally affect the way your apps run or if you simply want to keep private, sensitive data out of your version control system. The other day I ran into some trouble having [Heroku](https://www.heroku.com/) read the config variables of a Clojure app of mine. So here's how to get it working.| anmonteiro
[Jekyll](http://jekyllrb.com/) hosted in [Github Pages](https://pages.github.com) features a simple "Related posts" variable per post page, which contains the 10 most recent posts. As one might think, these most *recent* posts might not quite correspond, at all, to any *related* posts. So I devised a way to show recent **and** related posts in this blog using solely [Liquid](https://github.com/Shopify/liquid/wiki) tags.| anmonteiro
If you host your website, blog or project pages in [GitHub Pages](https://pages.github.com/), you might already be rolling your own [custom domain](https://help.github.com/articles/setting-up-a-custom-domain-with-github-pages/). However, while there is plenty of information on how to set that up, what you might not know is that you can also set up a custom subdomain for your project pages.| anmonteiro
Hello, and welcome to my humble corner in the Internet. This is where I'll focus on writing about **software engineering**, **programming** and **lifestyle**. As I'm hosting the blog on [GitHub Pages](https://pages.github.com), there are no comments for now. However, you can always reach me on Twitter - [@{{ site.author.twitter_username }}](http://twitter.com/{{ site.author.twitter_username }}) - or by [email](mailto:{{ site.author.email }}).| anmonteiro · Code ramblings
[ReScript](https://rescript-lang.org/), née [BuckleScript](https://bucklescript.netlify.app/), is a state-of-the-art compiler that used to target OCaml (and Reason), but is fast moving away from its parent language. OCaml compatibility is high on my list of desirable features, and I've been disillusioned with the direction the project has veered into. So I took matters into my own hands. Read on!| anmonteiro · Code ramblings