A round-up of improvements over the last two and a half years

or: How I learnt to stop worrying and love AI

A Bazel story of how we integrated a proprietary static analysis tool for fast, incremental analysis with Bazel.

How our CodeQL Wrapper simplifies adoption of GitHub's advanced security analysis tool

Announcing the Pup library.

rules_img is a Bazel ruleset for building and publishing OCI images that feel native to Bazel by treating images as metadata first and moving bytes only at the edges.

A tribute to our late colleague and friend.

The hidden complexity of dependency graphs

What goes into a static library, and how to make it smaller

Learn more about modernizing Bazel macros in your codebase

This post introduces Continuous Performance Testing (CPT) as an automated, CI/CD–integrated approach that provides real-time feedback and shifts testing left to catch issues early. It also highlights the value of automated load testing, thresholds (e.g., with K6) and a statistical approach for comparing with past performances.

Structured AI-assisted development workflows for engineering teams.

The second part of a tutorial on how to quickly write a formatter for a programming language using Topiary, our open-source formatting engine based on Tree-sitter.

Common issues and best practices managing large dependency graphs

The story of how I implemented qualified aliases in Liquid Haskell

What a build systems engineer might want to know

How to write production CodeQL code

Performance testing is a testing methodology that aims to investigate the responsiveness, speed, and stability of a system by evaluating its performance by testing functional requirements against non-functional criteria.

How to write your first CodeQL query

A whirlwind tour on how to integrate Nix with Buck2

Introducting the new LaunchDarkly Svelte SDK

A new multi-crate packaging feature for Cargo

The materials from a Bazel workshop we developed for a client are now publicly available

The challenge of measuring the immeasurable

A blog post about our blog

The shortest megaparsec tutorial there is to write your first DSL parser

Demonstrate the GHC wasm backend ghci browser mode and how it can be used to live-code a Haskell wasm frontend app.

This post introduces recursion schemes, a functional programming technique used to neatly express recursive algorithms and transformations on trees, and what they are good for in Rust specifically.

An overview of the improvements in the latest Liquid Haskell release

How we shoehorned a proprietary code coverage tool into Bazel's expectations of hermetic and reproducible build actions.

Evaluating retrieval-augmented generation (RAG) is easier than ever, but you need to keep a close eye on the LLMs that drive the evaluation metrics. We discuss some common pitfalls and solutions.

cooked-validators is a Haskell library to write offchain code and conduct testing activities over Cardano smart contracts. One of its main features is to create fully-fledged transactions from simple declarative skeletons.

In which we delve into the vagaries of Bash formatting and pit Topiary against shfmt in the ultimate, totally unbiased showdown.

An experience report of a somewhat large refactoring of Liquid Haskell

This blog post is a tutorial on how to quickly write a formatter for a programming language from scratch using Topiary, our open-source formatting engine based on tree-sitter.

Contract testing ensures that software components communicate correctly by verifying their 'contracts' or agreements, which define data formats, parameters, and expected responses, effectively creating a mutual understanding between components.

A detailed analysis of how migrating from Create React App to Vite enhances build speeds, reduces startup times, and improves the developer experience

A summary of the current support status of Template Haskell and ghci in GHC's wasm backend, explaining how it's implemented and laying out potential future improvements.

An introduction to Effect, an open-source library that promises to improve your TypeScript code

Efficient Google Cloud Storage Integration for Bazel

An empirical analysis of Python packages on PyPI and biomedical journals in 2023, with a focus on the quality of dependency declarations.

Internship report: Extensions to the reflection mechanism of Liquid Haskell to handle functions from dependencies.

A recent release of Nickel added algebraic data types and pattern matching. This blog post explains the motivation behind this addition, the design choices made, the considerations around backward compatibility and how ADTs can be useful for a configuration language.

No packet should pass unencrypted or unauthenticated.

A summary of the open-source work done by the Programming Languages & Compilers team at Tweag in the second quarter of 2024.

A tale of optimising GHC by improving sharing in its intermediate representation.

Discover how to build a high-performance image slider in React Native using Skia and Reanimated. This tutorial guides you through integrating Skia for sharp 2D graphics and Reanimated for fluid animations.

While a crucial phase of software development, integration testing faces challenges in terms of speed, reliability, and maintenance. This article discusses these common issues in the process.

Implementing an equivalent to the NixOS module system in Nickel

It has never been easier to write testable and type-safe Python.

An experience report on plugin upgrades

Do you regularly wonder where your time went during a week worth of work? We present work-dAIgest, a tool developed during Tweag's GenAI hackathon that aims to use data from standard workplace tools such as GitHub, Google Calendar, ... to create a summary of your work week (or any other time period), powered by open-source large language models (LLM).

Nickel 1.5 ships with a new contract evaluator in the LSP. Together with custom contracts, this enables a powerful and native way to extend the LSP with custom checks, from complex validation rules to enforcing security policies on your infrastructure-as-code.

A report on another 18 months in Nix documentation.

We re-implemented the nix remote protocol, declaratively

We just came out of Kubecon 2024. Here are our impressions of the trends and evolutions in infrastructure, configuration management and cloud native computing

We introduce an experimental framework for assessing RAG retrieval and explain its main components including benchmark creation, evaluation metrics, parameter space and experiment tracking. Whether you're deep in the field or just starting, this post is your gateway to understanding and improving RAG retrieval performance.

This is an answer to a request for comments issued by CISA about software identifiers that CISA encouraged me to publish as a separate blog post.

This blog post presents a safe API for destination-passing style programming using Linear Haskell against arbitrary functional data types.

Creating infrastructure for supporting Bazel remote execution with rules_nixpkgs

We introduce the many pitfalls of RAGs, including in retrieval, explain why we need systematic evaluation and provide a quick introduction to existing evaluation frameworks.

How GHC's design informs linear types

A summary of BazelCon Community Day 2023 in Munich

Introducing the lib.fileset Nix library for easy and safe source filtering

Make your C/C++ builds faster and smaller with debug fission.

tl;dr: We’re pleased to announce the beta release of Organist, a tool designed to ease the definition of reliable and low-friction development environments and workflows, building on the combined strengths of Nix and Nickel. A mess of cables and knobs I used to play piano as a…

A Bazel war story of how we integrated a proprietary code coverage tool that does not play according to Bazel's rules.

Explore how to write modular and reusable configuration in Nickel using its merge system.

Building the foundation to analyze your Software Supply Chain in Nix

Get better error reporting and LSP integration for your JSON Schemas in Nickel.

Use monad-bayes and rhine in your interactive machine learning application

Topiary's journey to a modern, user-friendly CLI experience.

FawltyDeps 0.13.0 introduces a brand new mapping strategy. In this post, we'll delve into the mechanics of how dependencies and imports are matched, as well as how you can leverage these new features to boost your Python dependency management workflow.

How to link against mimalloc when creating a static Linux executable for Rust, and why you should do the same.

Setting up a Bazel build for the ripgrep codebase

A GHC pattern for improving the user experience of type-level programs

How to build your Python monorepo from scratch: a simple CI

An overview of Meta's new build system Buck2 and how it differs from Bazel

Now that Topiary is out and supports OCaml, we need to package it. But how exactly does one package a Rust projet in OPAM, the OCaml Package Manager?

A revamp of the mechanism for introducing assumptions

A simple trick to fuzz Haskell programs with libFuzzer

halide-haskell is a Haskell wrapper for Halide that allows you write and just-in-time compile high-performance array and image processing kernels.

Translations of control flow can be tested before the rest of the code generator is ready. The tests examine sequences of abstract state transformations and observations.

With Nickel releasing 1.0 I'm excited to announce the 0.1 release of Tf-Ncl, a tool for writing Terraform deployments with Nickel instead of HCL.

Commandeering techniques from richly typed, functional languages into Python for fun and profit. In this episode: Testing strategies.

Today, I am very excited to announce the 1.0 release of Nickel. A bit more than one year ago, we released the very first public version Nickel (0.1). Throughout various write-ups and public talks (1, 2, 3), we’ve been telling the story of our dissatisfaction with the state of…

Embark with the High Assurance Software Group for a guided tour through the stages of a smart-contract audit, secret weapon included.

A new tool for visualising and exploring Bazel build graphs.

Using type-level dependency tags to verify a Haskell pipeline.

To allow innovation in medical imaging with AI, we need efficient and affordable ways to store and compute at scale.

How to build state machines in a composable way, controlling which transitions can be executed

How to build your Python monorepo from scratch: structure and tooling

How linear constraints get rid of scope functions and why it matters.

FawltyDeps is a new tool to help you identify undeclared and unused dependencies in your Python code, making your projects leaner and more reproducible.

We're happy to announce the first release of Topiary, a formatter for many languages that leverages Tree-sitter.

Tweag releases the full source code of the Chainsail web service, for sampling multimodal distributions, first announced in August 2022. This blog post gives a tour of the Chainsail service architecture, links out to the relevant parts of the source code and proposes possible extensions to Chainsail for which the Tweag team would welcome contributions from the community.

We went to FOSDEM23 and CfgMgmtCamp23. Here are my impressions of the trends and evolutions in infrastructure and configuration management

We present opam-nix, show how it helps to easily develop, build and test your OCaml projects with Nix

Announcement of smtlib-backends, a Haskell library providing a generic interface for interacting with SMT solvers using SMT-LIB

Make your NixOS development on macOS easier with this simple trick...

jupyterWith gets a new name and updates.

An experience report on improving HLS during my internship at Tweag.

How a linear constraint arrow relates to freezing arrays in Haskell.

The Nix `with` keyword is challenging, but we transpiled it to Nickel anyway.

Commandeering techniques from richly typed, functional languages into Python for fun and profit. In this episode: Typeclasses and continuation-passing style.

Learning and adopting Haskell is not hard with the right resources at hand.

How we gained 2–3% improvements in compile times by making GHC better at printing code.

What's new in Nickel 0.3.1

Getting an old Make based project building again after 10 years with the help of Bazel and Nix.

An internship report on my experience working on improving search.nixos.org and my internship at Tweag

A practical introduction to using Sparkle to write Haskell programs which interface with Delta Lake.

Revisit the fundamental concept of higher-order functions with a new perspective: interaction.

How and why to share threads in WASM workers (and when not to)

Announcing the GHC WebAssembly backend – present and future

Announcing the next version of jupyterWith.

Introduction to staged programming in Haskell with typeclasses

How to tap into the power of reinforcement learning while specifying and executing open games in Haskell.

Understanding the basic ideas of functional programming by writing a program using only sets and functions

Bazel avoids superfluous recompilation for free, but we can make it even better.

Setup two encrypted partitions with a shared Nix store

Exploration of a regression in GHC's bytecode generator performance

Tweag intern Abdellatif summarizes his internship, in which he augmented Chainsail with a Bayesian Replica Exchange scheme to improve sampling of multimodal distributions.

Painlessly switch your Haskell build from Cabal to Bazel

My experience improving monad-bayes, the probabilistic programming language package, as a Tweag fellow.

On a previous post, we explained how to write tests for stateful systems using traces — sequences of stateful actions — that can be combined and modified to write complex test cases easily and transparently. This post elaborates on the combinators used to generate new traces from…

Comparing Nix input hashes can guarantee that some refactors are bug-free.

Looking for a way to test Bazel-rules

A comprehensive report on what happened in four months of dedicated work on Nix documentation, and what I learned from it.

Learn the options for building a Nix flake out of a Rust workspace, outputting a mix of native code and WebAssembly.

A short dive into Nickel's reference interpreter

A collection of helpful tips for Bazel users.

A nixpkgs content database with graph building!

Commandeering techniques from richly typed, functional languages into Python for fun and profit. In this episode: Gradual typing and algebraic data types.

Cleanly and seamlessly add unit tests to your nix functions.

Introducing the Scalable Build Systems Team

How and when to use NixOS specialisations to manage different boot environments

We recently released a beta version of a web service called Chainsail, that helps with sampling multimodal probability distributions (you can check out our Chainsail announcement blog post for a quick introduction to this tool). In parallel, this post aims to illustrate a use…

Tweag announces Chainsail, a simple-to-use web service for better sampling of multimodal distributions with a scalable and auto-tuning Replica Exchange algorithm at its core.

Tweag's Nix team plans for the coming years

Limitations of the GHC profiler and announcement of the timestats library

New features to understand old verification failures

Nix is all about applying functional programming to files and processes.

The new Pirouette 2 introduces formal method techniques to the verification of smart contracts; in this post we focus particularly in how incorrectness logic helps this goal.

Announcing the new haskell_module rule in rules_haskell

Integrating Haskell Stack and Nix in a smooth yet non-invasive way, with an explanation, example and template.

How to get reproducible development environments for probabilistic programming packages such as PyMC3, Theano or TensorFlow using Nix.

Arnaud takes a step back from the slogans and examines the trade-offs between lazy and strict languages.

A presentation of an alternative encoding for optics such as lenses and prisms using existential types.

Why union and intersection contracts are hard in a lazy language, and how Nickel handles them.

Announcement of a WebAuthn Haskell library, and a description of how the protocol works

How to get things merged in large collaborative projects

Introduce the trick we use to run ghc test suite that needs to exec wasm code

What Happened On the morning of the 22nd of March, 2022, we were notified about the existence of an unknown critical vulnerability on one of Minswap’s contracts. Everyone here on the audit team was dismayed, since we had conducted an audit for Minswap not long before. We found…

Cheng demonstrates why it's challenging to port libffi to wasm32, how he implemented it, and how it's useful for cross-compiling the GHC RTS

I am excited to announce the first release of Nickel! In the original introductory blog post, I’ve written about why we, at Tweag, are developing yet another configuration language. Our goal is to empower people to write correct, programmable and maintainable configurations…

TLDR; Benchmarking in Rust is now faster, easier, and runs in your browser. My name is David and for the past three months, Tweag has generously sponsored my work on criterion.rs. Criterion.rs is a widely used (with nearly 1.4 million downloads in the last 90 days) benchmarking…

Use records to structure your Servant APIs

A tutorial on how to write a type-checking plugin for GHC

Why formatting chains of infix operators is hard in Haskell. And how I addressed it for Ormolu.

We discuss existing consensus models and why no global consensus mode is well suited to Trustix, opting for a user-defined algorithm instead.

How to automatically inject attacks and faults in safety tests using random traces.

On the relevance of Liquid Haskell in programming languages

In this post we introduce Merkle trees, the data structures needed to make the Trustix log append-only and searchable.

How to transparently separate resource allocation from business logic for scoped effects in Polysemy

Overview of the new features in Nix 2.4 and 2.5

Details about the 21.11 Nix Moscow Hackaton, and some suggestions for organizers of similar events.

In part two of this series on type-checking plugins, we will see how GHC's constraint solver works.

What had to change in the Nix internals to make it able to build content-addressed derivations?

A collection of ways various Tweagers develop in Haskell

On design choices to build a resource-safe interface for Sparkle using linear types

Small tutorial on using valgrind to find hot spots in ghc and other Haskell programs

An experience report on polishing Ormolu, the Haskell code formatter, during my internship at Tweag.

Why would you want to write a type-checking plugin? Many limitations of the GHC type-checker are exposed here.

Property test a denotational model of a data structure.

A discussion and benchmark of an alternative integrator for Hamiltonian Monte Carlo.

Introducing a library for writing data pipelines which compose well and fail early

Building a Go project using Bazel, generating build files with Gazelle

Notes from the sixth day of ICFP

Notes from the fifth day of ICFP

Notes from the fourth day of ICFP

Notes from the third day of ICFP

Notes from the second day of ICFP

Notes from the first day of ICFP

Announcing the gazelle_cabal tool for automatic Bazel rules generation for Cabal projects

An introduction to Integrated Shrinking and an implementation in QCheck (OCaml)

Apostolos Chalkis introduces dingo, a package for the analysis of metabolic networks, on which he worked as part of this Tweag fellowship.

What should the type of linear traverse be exactly?

Building OCaml projects with the new Bazel ruleset, OBazl

Deconstructing the various uses of type classes.

Announcing asciidoc-hs, a new AsciiDoc parser and converter in Haskell, adapted for use with Pandoc.

Announcing a simulator for Tenderbake

Tweag is looking for interns who want to contribute to Ormolu.

How to use lenses and other optics within an Arrow-based framework.

Define effect interpreters dynamically using reflection

Incubating the Haskell Foundation during 2020.

Discussion on using Bazel with inline-java

A dive into Nickel's gradual type system, which mixes dynamic and static typing

Better Go packaging with Gomod2nix

Understanding monads in OCaml: mixing promises and errors

This is another blog post on the upcoming content-addressed derivations for Nix. We’ve already explained the feature and some of its advantages, as well as the reasons why it isn’t easy to implement. Now we’re going to talk about about a concrete user-facing change that this…

Announcing linear-base, a standard library for linearly typed Haskell programs.

This post is about compiling refinement types into a dependently typed core language, my project as an Open Source Fellow for Tweag. The post assumes some passing familiarity with the concept of dependent types, and little else. By reading this post, you will learn what a…

A call to action to improve GHC's performance via a paid internship

Presenting Nickel: better configuration for less Programming with contracts in Nickel Types à la carte in Nickel Great Nickel configurations from little merges grow In a previous post, I gave a taste of Nickel, a configuration language we are developing at Tweag. One cool feature…

How to break encapsulation and import a hidden value in Haskell.

Trustix aims at enhancing trust in software binaries and improve reproducibility tracking using distributed binary caches.

An applicative functor to define shrinkers

Why Template Haskell is hard for cross compilation and how Asterius does it

Why wasn't Nix built with a content-addressed store?

Destinations give you control over your memory allocations, and linear types make them pure.

In the final post of Tweag's four-part series, we discuss Replica Exchange, a powerful MCMC algorithm designed to improve sampling from multimodal distributions. An illustrative example and, as always, an interactive Python notebook with easy-to-modify code lead to an intuitive understanding and invite experimentation.

Presenting Nickel: better configuration for less Programming with contracts in Nickel Types à la carte in Nickel Great Nickel configurations from little merges grow We are making the Nickel repository public. Nickel is an experimental configuration language developed at Tweag…

Just a few days ago, Cloudflare and Stack builders published a excellent blog post where they demonstrate how to deploy a Haskell program to Cloudflare Worker with Asterius. In this post we go one step further and show that you can deploy full-fledged servant applications just as…

Summary of the Tweag open source fellowship work related to ghcide

Bazel gains support for creating fully statically linked Haskell binaries with rules_haskell and rules_nixpkgs.

Meet Lagoon, a new open source tool for centralizing and querying semi-structured datasets.

In making a build system for your software, you codified the dependencies between its parts. But, did you account for implicit software dependencies, like system libraries and compiler toolchains? Implicit dependencies give rise to the biggest and most common problem with…

Why content-addressability is desirable for Nix.

What do we need to focus on to increase adoption of Nix?

Learn how to use Nix to create highly reproducible Python builds that are aware of native dependencies.

Learn about Hamiltonian Monte Carlo, and how to implement it from scratch.

How to manage NixOS systems using Nix flakes.

The second call for projects for the Tweag Open Source Fellowship is open and brings financial support and mentorship for Open source contributors.

Announcement of the upcoming QualifiedDo language extension.

How to setup a Buildkite-based CI for Nix projects with workers running on GCP.

How we ensured that the implementation of random v1.2 produces higher quality random numbers than v1.1.

How Nix flakes enable caching of evaluation results of Nix expressions.

Looking back at the journey which brought us there, and forward to what still lies ahead.

How Nix is collaborating with Software Heritage for long-term software reproducibility.

Benchmarks of inline-java and a discussion of its performance trade-offs.

Tweag introduces our first cohort of Open Source Fellows.

An introduction to Nix flakes and a tutorial on how to use them.

How to build a complete Haskell project with Bazel.

How to derive instances via arbitrary isomorphisms.

Imprecise, synchronous, asynchronous exceptions: what do they mean, and what to do with them.

How to set up a remote Bazel cache, and why it is a good idea.

This blog post describes the tradeoffs of the choice between eager and lazy instantiation of type variables in GHC.

During my internship, I implemented the explicit specificity proposal to make GHC type signatures complete.

Peirce divides reasoning into three complementary processes: deduction, abduction and induction. In this post, I will show how these logical processes relate to software.

In this blog post series, we're going to lead you through Bayesian modeling in Haskell with the monad-bayes library. In the third part of the series, we setup a simple Bayesian neural network.

A primer on the interaction between linear types and exceptions in Haskell.

The first call for the new Tweag Open Source Fellowship is open. It offers financial support and mentorship to open source contributors.

In this post about inline-java I aim to walk you through the upcoming safe interface of the library, which allows detecting memory management mistakes at compile time using linear types.

This post describes a profiling technique for Haskell codebases that yields faithful results and is well adapted to large repositories.

Haskell's Data and Control module hierarchies have always bugged me. Now, I understand that the intuition behind the Data/Control separation is rooted in a deep technical justification.

In this second post of Tweag's four-part series, we discuss Gibbs sampling, an important MCMC-related algorithm which can be advantageous when sampling from multivariate distributions. Two different examples and, again, an interactive Python notebook illustrate use cases and the issue of heavily correlated samples.

Asterius compiles Haskell code into WebAssembly code to be executed in a browser or in Node.js. It has reached a new milestone by being able to compile the diagrams library and its dependencies.

How to use the Makam metalanguage to implement an executable formal semantics for a simple language.

Learn how Nix's new post-build hooks feature can automatically sign and upload artifacts to a binary cache in a trusted way.

Here's Part 2 in Tweag's Series about Bayesian modeling in Haskell with the monad-bayes library.

We're happy to announce the first release of Porcupine, an open source framework to express portable and customizable data pipelines.

In this first post of Tweag's four-part series on Markov chain Monte Carlo sampling algorithms, you will learn about why and when to use them and the theoretical underpinnings of this powerful class of sampling methods. We discuss the famous Metropolis-Hastings algorithm and give an intuition on the choice of its free parameters. Interactive Python notebooks invite you to play around with MCMC yourself and thus deepen your understanding of the Metropolis-Hastings algorithm.

We're happy to announce the first release of Ormolu, a formatter for Haskell source code.

Bazel gets native support for third-party Haskell libraries and building Cabal packages since the 0.10 release of rules_haskell.

I got the opportunity to work on Bazel's Persistent Worker Mode for GHC during my internship at Tweag. My goal was to improve the mode of communication between Bazel and the Haskell GHC compiler.

In this blog post series, we're going to lead you through Bayesian modeling in Haskell with the monad-bayes library. In the first part of the series, we introduce two fundamental concepts of `monad-bayes`: `sampling` and `scoring`.

I got the opportunity to work on Asterius, a new Haskell to WebAssembly compiler, during my internship at Tweag. My task was to get anything numerics-related stabilized in its compiled code.

People keep asking me, “What's the point of Haskell, why do you folks even use it?”. How can you answer this?

We visualize large collections of Haskell and Python source codes as 2D maps using methods from Natural Language Processing (NLP) and dimensionality reduction and find a surprisingly rich structure for both languages. Clustering on the 2D maps allows us to identify common patterns in source code which give rise to these structures. Finally, we discuss this first analysis in the context of advanced machine learning-based tools performing automatic code refactoring and code completion.

Every day we write repetitive code. A lot of it is boilerplate that you write only to satisfy your compiler/interpreter. But how do languages differ in their boilerplate content? We explore these questions using data sets of Python and Haskell code.

Edsger Dijkstra took issue with the “unbridled” use of the programming construct in 1968. He noted that our already limited ability to reason about the dynamic behaviour of imperative programs was nigh impossible in the presence of -jumps to arbitrary labels. With , control flow…

If we think of the average Haskeller, who do we see? A poor, broken person. Tired head falls into the open palms, sobbing, deprived of the basic human right for automated source code formatting. Is it at all conceivable that so many attempts were made and none quite succeeded…

Tweag.io has a bit of a history with language interop. By this point, we created or collaborated with others in the community on HaskellR, inline-c, inline-java, and now inline-js. The original idea for this style of interop was realized in language-c-inline by Manuel Chakravarty…

Inspired by the Event Horizon Telescope images, we develop a quick exploratory study about future possibilities of this technology called the Sneakernet: Could massive data transfer give a new live to the homing pigeon industry? How about using transportation means that are optimized to carry incredible amounts of weight? Or transportation means that are designed to be fast as a bullet?

I want to present you a Terraform plugin for securely managing secrets that was written for Digital Asset, who kindly allowed me to open source it. The general idea of this plugin is to protect secrets by making use of Terraform’s state. Terraform maintains the state of the world…

Today we’re excited to announce lorri, a new tool for NixOS, Linux, and macOS that makes developing with Nix even nicer: When people try lorri, we often hear that it is more magical than they expected. What is lorri? lorri is a nix-shell replacement for project development…

There has been recent online discussions about impredicative encoding (aka final encoding) of free monads. Capabilities-as-type-classes, as embodied by the capability library, are essentially the same thing.

The time has come again to invite applications for Tweag I/O’s paid internship programme this summer. For the past few years Tweag has taken on a number of students interested in developing their experience working on projects of benefit to the wider programming community. This…

In a recent project I was tasked with creating a local testing environment for a Kubernetes cluster the client was actively working on. The main requirements were: Cross platform: It should work on Linux and macOS. Ease of use: The setup should be easy to use. Suitable for CI…

Millions of Jupyter notebooks are spread over the internet - machine learning, astrophysics, biology, economy, you name it. What a great age for reproducible science! Or that's what you think until you try to actually run these notebooks. Then you realize that having understandable high-level code alone is not enough to reproduce something on a computer. JupyterWith is a solution to this problem.

Have you ever needed to execute in another computer a binary that you have built, only to find that it doesn’t work because it depends on shared libraries that aren’t installed? Or even worse, you don’t have admin rights on the machine, so you cannot install the correct…

Haskell is in a way a unique language. It is, to be clear, a language people and businesses use for building “serious stuff”, yet it is also a language which remains a platform for experimentation with functional programming. This means that the teams which develop in Haskell…

The repositories of distributions such as Debian and Nixpkgs are among the largest collections of open source (and some unfree) software. They are complex systems that connect and organize many interdependent packages. In this blog post I'll try to shed some light on them from the perspective of Nixpkgs, mostly with visualizations of its complete dependency graph.

Introduction Haskell and data science - on first sight a great match: native function composition, lazy evaluation, fast execution times, and lots of code checks. These sound like ingredients for scalable, production-ready data transformation pipelines. What is missing then? Why…

Getting your browser to print “Hello World!” is fun, and a milestone for compiler writers targeting the web. Soon expectations change. Can you call existing code? Can you write a moderately complex web app? How fast does it run? Previously, we showed how Haskell can call…

If you’re a conscientious developer like I am my boss is, you probably have a benchmark suite for the programs and libraries you develop. This allows you to see the impact of your changes on the performance of your applications. However, the temporal aspect of these benchmark…

About a year ago, Michael Snoyman made a blog post about the ReaderT pattern. Ostensibly, it’s a blog post about preferring to encode state as -s when you can. But that’s not how we read it. What we saw first and foremost is a story about using extensional type classes describing…

Note: since Mar 19, 2020, we’ve changed the JavaScript import syntax: the -th argument is now instead of . The code snippets in this post have been adjusted accordingly. Previously, we announced the Asterius compiler, a new GHC-backend that translates Haskell to WebAssembly…

Funflow is a workflow management tool. It turns out that workflow management tools and build tools are closely related. So if you’re more familiar with the latter, this post might be of interest to you. We’ll be illustrating some of Funflow’s features by implementing Make on top…

In an earlier blog post, we discussed how streaming libraries help writing composable programs without lazy I/O. We showed, for a simple program, how using a streaming library helps reducing the amount of unaided bookkeeping that the programmer needs to do in order to make it…

Asterius is an experimental WebAssembly backend for GHC. We aim to support most GHC features while making the emitted WebAssembly code as small and fast as possible. The project recently reached an exciting milestone: for the first time, simple Haskell functions can be compiled…

Funflow is a system for building and running workflows. It’s a system we’ve been working on for the last few months with a small number of clients. In this blog post we’ll talk about what workflows are, why we built Funflow, and what we’d like to do with it in the future. What is…

We are happy to announce that Stackage HEAD is now functional. For those who had missed the original blog post, or already forgot it, let’s refresh the idea behind Stackage HEAD. Each Stackage Nightly is a build plan that includes a large set of real-world packages that are known…

We’re hiring multiple software engineers to join our team. Our mission: deliver correct high-performance software faster. We have found functional programming in particular to be an enabling factor for us on some of the most ambitious projects we’ve faced for our clients…

This is the second post in our series about building polyglot projects using Bazel. You might find it useful to start with our first installment. A is an extraordinary thing. You specify a set of targets, you tell Make what the dependencies are between these targets, and Make…

In the “all about reflection” post, we introduced the data type. Any sorting function should have the type . However, this doesn’t actually guarantee that is indeed a sorting function: it only says that is a sorted list, but not that it is actually a sort of . For example is…

Publishing code to the world is easy these days: take your code, tack some extra metadata onto it, call that a package and upload it to npmjs.com / crates.io / Hackage / etc. It’s also easy for other developers to include your code as part of their project: build tools are…

Tweag I/O is inviting applications from students for our paid internship programme this summer. If you’re a student excited about working with Haskell, Nix and similar things, then get in touch! In previous years, our interns have worked on a variety of projects across research…

The utility of free monads can show up in surprising places. One of the projects I’m working on is an AI, and part of the strategy that it uses for responding to user input is quite simple: it generates many possible responses, and then evaluates them. Most of the computations it…

An important device in the tool belt I carry around everyday is type class reflection. I don’t reach for it often, but it can be very useful. Reflection is a little known device. And for some reason it is often spoken of with a hint of fear. In this post, I want to convince you…