We Are Writing

A tech agency in London writing about what we love.

Articles in Dev

A MobX introduction and case study

01 Nov 2016 — Dev

Reading time: ~15 minutes.

MobX (previously mobservable) is a state management library for JavaScript frontend application. This article introduces it with examples as well as showing how it works in a real app with TypeScript. It is based on a talk I gave at the Osaka Web designers and developers meetup recently. »

Keeping the user serving path fast

01 Jun 2016 — Dev

Reading time: ~10 minutes.

Serving web requests should be fast and error free. There's some evidence that slower pages result in less browsing.

We'll discuss a few strategies to keep requests fast. »

Introducing Tera, a template engine in Rust

15 Apr 2016 — Dev

Reading time: ~15 minutes.

Back in October 2015, I tried Rust for web services and found the ecosystem lacking at the time. That's why I've been working on porting some of the tools we use in Proppy to Rust: jwt, bcrypt (granted that Argon2 seems superior) and a migration tool. While I mostly do SPAs these days and don't write many templates in the backend, I still need one for some occasions. When using Python, I like Jinja2 and Django templates. Here's how I attempted to port them to Rust and the result is Tera. »

Flow and TypeScript part 2: TypeScript

20 Nov 2015 — Dev

Reading time: ~10 minutes.

Continuing from the first part that introduced Flow, we are now going to have a look at TypeScript.

TypeScript is a superset of JavaScript that compiles to several targets, including ES5 and ES6. The current version of TypeScript (1.6 at the time of writing) now supports JSX, which was the main blocker for most people using React. »

Flow and TypeScript part 1: Flow

13 Nov 2015 — Dev

Reading time: ~10 minutes.

As front-end applications grow in complexity, more and more developers are looking for ways to make development and maintenance more scalable. For some people it means foregoing JavaScript itself and using languages such as Clojurescript, Elm or Purescript while others want to keep using JavaScript, especially now that ES6 makes writing it tolerable.

A simple way to make a codebase easier to maintain and to grow is to have types and that is exactly what Flow and TypeScript offer, albeit in different ways. »

A lot of websockets in Haskell

05 Nov 2015 — Dev

Reading time: ~20 minutes.

I really enjoyed reading how the phoenix-framework people managed to get to two million active websocket connections.

I've heard some very smart people say that Haskell has an amazing runtime with very cheap threads. I have no reason to disbelieve them but we thought it'd be fun to see how Haskell fares in a comparable setup.


Writing my first Rust crate: jsonwebtoken

04 Nov 2015 — Dev

Reading time: ~10 minutes.

After looking into Rust for webservices, I concluded that, while it was not mature enough yet in my opinion, the language itself is quite nice and I would be interested in writing more of it. So here it is, my first crate (the name for packages in Rust): jsonwebtoken (code on github). »

Trying Rust for web services

01 Oct 2015 — Dev

Reading time: ~15 minutes.

Developing web apps in dynamic languages is a breeze when using frameworks like Django for Python. The downsides are that software written in dynamic languages is harder, at least in my opinion, to maintain, to refactor and you also need to write tests to cover potential errors that would simply not be possible with a compiler. »

How to use NixOps in a team

09 Sep 2015 — Dev

NixOps is a fantastic tool for getting reproducible servers running in no time. NixOps can deploy to many different targets including VirtualBox, Google's GCE and Amazon's cloud services AWS.

As we have discovered NixOps has the downside of storing all its state (such as the IP address of a server) in a binary SQLite database. That in combination with some defaults such as absolute paths make it a bit cumbersome to share deployments. This post describes how to work around these issues.


A tour of modern frontend with React and Flux

25 Aug 2015 — Dev

Reading time: ~10 minutes.

In this article we are going to have a look at my preferred set of tools for writing React/Flux web apps. If you don't know React or Flux, you can finds their documentation at their respective websites: React, Flux. »

Using Protobuf instead of JSON to communicate with a frontend

04 Jun 2015 — Dev

Reading time: ~15 minutes.

Protocol buffers (or other binary serialization formats like Thrift) are widely used to communicate between services. JSON is overwhelmingly used for backend <-> frontend communication and for APIs.
Let's see what a client/server using Protobuf would look like. »

Comparing the weather of places I've lived in

18 May 2015 — Dev

Reading time: ~25 minutes.

I have lived in 4 countries on 3 continents (so far).
When people ask me about these places, the first thing that comes to my mind is the weather. Having lived in these places I knew roughly how they compared but was curious about the exact numbers. What better way than to visualize data than a ipython notebook! »

gulp-sass v2 released

07 May 2015 — Dev

Reading time: ~15 minutes.

gulp-sass v2 was released today!
In itself, this is not a big change as this is simply a wrapper for node-sass which uses libsass so, while this version is a complete rewrite this is not the important news. The important news is that it ships with node-sass v3 which is using libsass 3.2.2. »

Migrating to gulp 4 by example

13 Mar 2015 — Dev

Reading time: ~20 minutes.

Last year I wrote a blog post on my personal website (you can see it here Gulp by example ) showing what gulp was and making a demo project using it. Since then, the team behind it did a lot of work on v4 of gulp which, while not released as of the writing of the post, is stable enough to be used. »

Experience report: Rocket lander in Elm

15 Feb 2015 — Dev

Reading time: ~10 minutes.

Writing anything substantial in JavaScript is hard because JavaScript lacks many of the tools programmers expect these days, like a coherent and strong type system. »