I recently joined Matt Moore on LambdaShow. We spent some time discussing Rust, and one point I made was that, in my experience with Rust, ergonomics go something like this: Beginner: oh cool, that worked, no problem Advanced beginner: wait… why exactly did that work 99 other times? Why is it failing this time? I’m […]
Rust is a relatively new and promising language that offers improvements in software in terms of safety and speed. We’ll cover if adopting Rust into your organization makes sense and where you would want to add it to an existing software stack. Advantages of Rust Background Rust was originally created by Mozilla in order to […]
Based on actual events. Let’s say you’ve got a blog. The blog has a bunch of posts. Each post has a title and a set of tags. The metadata for these posts is all contained in TOML files in a single directory. (If you use Zola, you’re pretty close to that.) And now you need […]
A beginner’s guide to writing your DevOps tools in Rust. Introduction In this blog post we’ll cover some basic DevOps use cases for Rust and why you would want to use it. As part of this, we’ll also cover a few common libraries you will likely use in a Rust-based DevOps tool for AWS. If […]
This blog post is a direct follow up on my previous blog post on different levels of async in Rust. You may want to check that one out before diving in here. Alright, so now we know that we can make our programs asynchronous by using non-blocking I/O calls. But last time we only saw […]
First there was cooperative multiprocessing. Then there were processes. An operating system could run multiple processes, each performing a series of sequential, blocking actions. Then came threads. A single processes could spawn off multiple threads, each performing its own series of sequential, blocking actions. (And really, the story starts earlier, with hardware interrupts and the […]
In this post, I describe my personal journey as a developer skeptical of the seemingly ever-growing, ever more complex, array of “ops” tools. I move towards adopting some of these practices, ideas and tools. I write about how this journey helps me to write software better and understand discussions with the ops team at work. […]
At FP Complete, we have long spoken about the three pillars of a software development language: productivity, robustness, and performance. Often times, these three pillars are in conflict with each other, or at least appear to be. Getting to market quickly (productivity) often involves skimping on quality assurance (robustness), or writing inefficient code (performance). Or […]
Most of the discussions we have in the software industry today revolve around developer productivity: How do we make it possible for fewer developers to produce more software in less time? Reducing the upfront costs and delivering quickly is essentially the mantra of the startup world: Move fast and break things. However, the vast majority […]
Preface for unaware When you install a particular version of GHC on your machine it comes with a collection of “boot” libraries. What does it mean to be a “boot” library? Quite simply, a library must be used for implementation of GHC and other core components. Two such notable libraries are base and ghc. All […]