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. »
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. »
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. »
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. »
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.
»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). »
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. »
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.
»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. »
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.
»
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!
»
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.
»
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. »
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. »