Technical writing from Tweag engineers on build systems, functional programming, type systems, open source, infrastructure, machine learning, and software practice.
The CodeCommons project had a complex architecture with multiple services and a plethora of configuration formats and files that are often filled in via ad-hoc templating. This made for complex maintenance and hard to discover bugs. In this blog post, I describe how the Nickel configuration language could be used for great good in this context and tell you about our experience adopting it.
8 October 2026
Just do it – it’s simpler than you’d think!
24 September 2026
Using Tricorder and its MCP server with coding agents.
17 September 2026
An internship experience report on reenabling type class support in Liquid Haskell
10 September 2026
An experiment in constraining coding agent output with formal proofs
23 July 2026
A retrospective on five years and twenty-plus Cardano smart-contract audits at Tweag.
9 July 2026
How Topiary can now format embedded languages in OCamllex and Markdown files, and how the injection system works under the hood.
18 June 2026
Here is how you can implement sheaves in Haskell
11 June 2026
A self-contained example showcasing formal verification using Liquid Haskell
1 June 2026
Tweag proposals for Intersect funding submitted on chain
30 April 2026
Tweag proposals for Intersect funding submitted on chain
25 April 2026
A statement from Tweag by Modus Create to the Cardano community for 2025
16 April 2026
When the code's in the crib, ma...
2 April 2026
Learn how to minimize risks when having third-party dependencies.
19 February 2026
A round-up of improvements over the last two and a half years
12 February 2026
or: How I learnt to stop worrying and love AI
5 February 2026
A Bazel story of how we integrated a proprietary static analysis tool for fast, incremental analysis with Bazel.
15 January 2026
How our CodeQL Wrapper simplifies adoption of GitHub's advanced security analysis tool
8 January 2026
Announcing the Pup library.
18 December 2025
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.
16 December 2025
A tribute to our late colleague and friend.
4 December 2025
The hidden complexity of dependency graphs
1 December 2025
How our plans for history expiry have evolved, and what we're doing now.
27 November 2025
Watch our talks and training from BazelCon 2025
27 November 2025
What goes into a static library, and how to make it smaller
20 November 2025
Learn more about modernizing Bazel macros in your codebase
2 October 2025
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.
18 September 2025
Common issues and best practices managing large dependency graphs
11 September 2025
The story of how I implemented qualified aliases in Liquid Haskell
4 September 2025
What a build systems engineer might want to know
28 August 2025
How to write production CodeQL code
7 August 2025
How to write your first CodeQL query
31 July 2025
A whirlwind tour on how to integrate Nix with Buck2
10 July 2025
A new multi-crate packaging feature for Cargo
3 July 2025
The materials from a Bazel workshop we developed for a client are now publicly available
28 May 2025
Tweag proposals for Intersect funding submitted on chain
26 May 2025
Tweag proposals for Intersect funding submitted on chain
15 May 2025
A blog post about our blog
5 May 2025
24 April 2025
The shortest megaparsec tutorial there is to write your first DSL parser
17 April 2025
Demonstrate the GHC wasm backend ghci browser mode and how it can be used to live-code a Haskell wasm frontend app.
10 April 2025
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.
1 April 2025
20 March 2025
An overview of the improvements in the latest Liquid Haskell release
6 March 2025
How we shoehorned a proprietary code coverage tool into Bazel's expectations of hermetic and reproducible build actions.
27 February 2025
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.
20 February 2025
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.
13 February 2025
In which we delve into the vagaries of Bash formatting and pit Topiary against shfmt in the ultimate, totally unbiased showdown.
6 February 2025
An experience report of a somewhat large refactoring of Liquid Haskell
30 January 2025
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.
21 November 2024
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.
17 October 2024
Efficient Google Cloud Storage Integration for Bazel
24 September 2024
An empirical analysis of Python packages on PyPI and biomedical journals in 2023, with a focus on the quality of dependency declarations.
12 September 2024
Internship report: Extensions to the reflection mechanism of Liquid Haskell to handle functions from dependencies.
5 September 2024
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.
29 August 2024
No packet should pass unencrypted or unauthenticated.
22 August 2024
A summary of the open-source work done by the Programming Languages & Compilers team at Tweag in the second quarter of 2024.
15 August 2024
A tale of optimising GHC by improving sharing in its intermediate representation.
20 June 2024
Implementing an equivalent to the NixOS module system in Nickel
6 June 2024
It has never been easier to write testable and type-safe Python.
30 May 2024
An experience report on plugin upgrades
21 May 2024
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).
16 May 2024
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.
2 May 2024
A report on another 18 months in Nix documentation.
25 April 2024
We re-implemented the nix remote protocol, declaratively
18 April 2024
We just came out of Kubecon 2024. Here are our impressions of the trends and evolutions in infrastructure, configuration management and cloud native computing
12 March 2024
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.
7 March 2024
This blog post presents a safe API for destination-passing style programming using Linear Haskell against arbitrary functional data types.
29 February 2024
Creating infrastructure for supporting Bazel remote execution with rules_nixpkgs
6 February 2024
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.
18 January 2024
How GHC's design informs linear types
7 December 2023
A summary of BazelCon Community Day 2023 in Munich
28 November 2023
Introducing the lib.fileset Nix library for easy and safe source filtering
23 November 2023
Make your C/C++ builds faster and smaller with debug fission.
16 November 2023
9 November 2023
A Bazel war story of how we integrated a proprietary code coverage tool that does not play according to Bazel's rules.
2 November 2023
Explore how to write modular and reusable configuration in Nickel using its merge system.
26 October 2023
Building the foundation to analyze your Software Supply Chain in Nix
19 October 2023
Get better error reporting and LSP integration for your JSON Schemas in Nickel.
12 October 2023
Use monad-bayes and rhine in your interactive machine learning application
5 October 2023
Topiary's journey to a modern, user-friendly CLI experience.
21 September 2023
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.
10 August 2023
How to link against mimalloc when creating a static Linux executable for Rust, and why you should do the same.
27 July 2023
Setting up a Bazel build for the ripgrep codebase
20 July 2023
A GHC pattern for improving the user experience of type-level programs
13 July 2023
How to build your Python monorepo from scratch: a simple CI
6 July 2023
An overview of Meta's new build system Buck2 and how it differs from Bazel
29 June 2023
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?
22 June 2023
A revamp of the mechanism for introducing assumptions
15 June 2023
A simple trick to fuzz Haskell programs with libFuzzer
8 June 2023
halide-haskell is a Haskell wrapper for Halide that allows you write and just-in-time compile high-performance array and image processing kernels.
1 June 2023
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.
30 May 2023
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.
25 May 2023
Commandeering techniques from richly typed, functional languages into Python for fun and profit. In this episode: Testing strategies.
17 May 2023
11 May 2023
Embark with the High Assurance Software Group for a guided tour through the stages of a smart-contract audit, secret weapon included.
4 May 2023
A new tool for visualising and exploring Bazel build graphs.
27 April 2023
Using type-level dependency tags to verify a Haskell pipeline.
20 April 2023
To allow innovation in medical imaging with AI, we need efficient and affordable ways to store and compute at scale.
13 April 2023
How to build state machines in a composable way, controlling which transitions can be executed
4 April 2023
How to build your Python monorepo from scratch: structure and tooling
23 March 2023
How linear constraints get rid of scope functions and why it matters.
14 March 2023
FawltyDeps is a new tool to help you identify undeclared and unused dependencies in your Python code, making your projects leaner and more reproducible.
9 March 2023
We're happy to announce the first release of Topiary, a formatter for many languages that leverages Tree-sitter.
2 March 2023
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.
23 February 2023
We went to FOSDEM23 and CfgMgmtCamp23. Here are my impressions of the trends and evolutions in infrastructure and configuration management
16 February 2023
We present opam-nix, show how it helps to easily develop, build and test your OCaml projects with Nix
14 February 2023
Announcement of smtlib-backends, a Haskell library providing a generic interface for interacting with SMT solvers using SMT-LIB
9 February 2023
Make your NixOS development on macOS easier with this simple trick...
2 February 2023
jupyterWith gets a new name and updates.
31 January 2023
An experience report on improving HLS during my internship at Tweag.
26 January 2023
How a linear constraint arrow relates to freezing arrays in Haskell.
24 January 2023
The Nix `with` keyword is challenging, but we transpiled it to Nickel anyway.
19 January 2023
Commandeering techniques from richly typed, functional languages into Python for fun and profit. In this episode: Typeclasses and continuation-passing style.
12 January 2023
Learning and adopting Haskell is not hard with the right resources at hand.
22 December 2022
How we gained 2–3% improvements in compile times by making GHC better at printing code.
20 December 2022
What's new in Nickel 0.3.1
15 December 2022
Getting an old Make based project building again after 10 years with the help of Bazel and Nix.
13 December 2022
An internship report on my experience working on improving search.nixos.org and my internship at Tweag
8 December 2022
A practical introduction to using Sparkle to write Haskell programs which interface with Delta Lake.
1 December 2022
Revisit the fundamental concept of higher-order functions with a new perspective: interaction.
24 November 2022
How and why to share threads in WASM workers (and when not to)
22 November 2022
Announcing the GHC WebAssembly backend – present and future
17 November 2022
Announcing the next version of jupyterWith.
15 November 2022
Introduction to staged programming in Haskell with typeclasses
10 November 2022
How to tap into the power of reinforcement learning while specifying and executing open games in Haskell.
8 November 2022
Understanding the basic ideas of functional programming by writing a program using only sets and functions
3 November 2022
Bazel avoids superfluous recompilation for free, but we can make it even better.
1 November 2022
Setup two encrypted partitions with a shared Nix store
27 October 2022
Exploration of a regression in GHC's bytecode generator performance
25 October 2022
Tweag intern Abdellatif summarizes his internship, in which he augmented Chainsail with a Bayesian Replica Exchange scheme to improve sampling of multimodal distributions.
20 October 2022
Painlessly switch your Haskell build from Cabal to Bazel
18 October 2022
My experience improving monad-bayes, the probabilistic programming language package, as a Tweag fellow.
14 October 2022
11 October 2022
Comparing Nix input hashes can guarantee that some refactors are bug-free.
6 October 2022
Looking for a way to test Bazel-rules
29 September 2022
A comprehensive report on what happened in four months of dedicated work on Nix documentation, and what I learned from it.
22 September 2022
Learn the options for building a Nix flake out of a Rust workspace, outputting a mix of native code and WebAssembly.
20 September 2022
A short dive into Nickel's reference interpreter
15 September 2022
A collection of helpful tips for Bazel users.
13 September 2022
A nixpkgs content database with graph building!
8 September 2022
Commandeering techniques from richly typed, functional languages into Python for fun and profit. In this episode: Gradual typing and algebraic data types.
1 September 2022
Cleanly and seamlessly add unit tests to your nix functions.
25 August 2022
Introducing the Scalable Build Systems Team
18 August 2022
How and when to use NixOS specialisations to manage different boot environments
11 August 2022
9 August 2022
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.
4 August 2022
Tweag's Nix team plans for the coming years
28 July 2022
Limitations of the GHC profiler and announcement of the timestats library
21 July 2022
New features to understand old verification failures
14 July 2022
Nix is all about applying functional programming to files and processes.
1 July 2022
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.
23 June 2022
Announcing the new haskell_module rule in rules_haskell
2 June 2022
Integrating Haskell Stack and Nix in a smooth yet non-invasive way, with an explanation, example and template.
26 May 2022
How to get reproducible development environments for probabilistic programming packages such as PyMC3, Theano or TensorFlow using Nix.
12 May 2022
Arnaud takes a step back from the slogans and examines the trade-offs between lazy and strict languages.
5 May 2022
A presentation of an alternative encoding for optics such as lenses and prisms using existential types.
28 April 2022
Why union and intersection contracts are hard in a lazy language, and how Nickel handles them.
21 April 2022
Announcement of a WebAuthn Haskell library, and a description of how the protocol works
14 April 2022
How to get things merged in large collaborative projects
31 March 2022
Introduce the trick we use to run ghc test suite that needs to exec wasm code
25 March 2022
17 March 2022
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
11 March 2022
3 March 2022
24 February 2022
Use records to structure your Servant APIs
17 February 2022
A tutorial on how to write a type-checking plugin for GHC
10 February 2022
Why formatting chains of infix operators is hard in Haskell. And how I addressed it for Ormolu.
3 February 2022
We discuss existing consensus models and why no global consensus mode is well suited to Trustix, opting for a user-defined algorithm instead.
26 January 2022
How to automatically inject attacks and faults in safety tests using random traces.
19 January 2022
On the relevance of Liquid Haskell in programming languages
14 January 2022
In this post we introduce Merkle trees, the data structures needed to make the Trustix log append-only and searchable.
5 January 2022
How to transparently separate resource allocation from business logic for scoped effects in Polysemy
20 December 2021
Overview of the new features in Nix 2.4 and 2.5
15 December 2021
Details about the 21.11 Nix Moscow Hackaton, and some suggestions for organizers of similar events.
9 December 2021
In part two of this series on type-checking plugins, we will see how GHC's constraint solver works.
2 December 2021
What had to change in the Nix internals to make it able to build content-addressed derivations?
25 November 2021
A collection of ways various Tweagers develop in Haskell
17 November 2021
On design choices to build a resource-safe interface for Sparkle using linear types
4 November 2021
Small tutorial on using valgrind to find hot spots in ghc and other Haskell programs
28 October 2021
An experience report on polishing Ormolu, the Haskell code formatter, during my internship at Tweag.
21 October 2021
Why would you want to write a type-checking plugin? Many limitations of the GHC type-checker are exposed here.
13 October 2021
Property test a denotational model of a data structure.
30 September 2021
A discussion and benchmark of an alternative integrator for Hamiltonian Monte Carlo.
23 September 2021
Introducing a library for writing data pipelines which compose well and fail early
8 September 2021
Building a Go project using Bazel, generating build files with Gazelle
30 August 2021
Notes from the sixth day of ICFP
27 August 2021
Notes from the fifth day of ICFP
26 August 2021
Notes from the fourth day of ICFP
25 August 2021
Notes from the third day of ICFP
24 August 2021
Notes from the second day of ICFP
23 August 2021
Notes from the first day of ICFP
28 July 2021
Announcing the gazelle_cabal tool for automatic Bazel rules generation for Cabal projects
21 July 2021
An introduction to Integrated Shrinking and an implementation in QCheck (OCaml)
14 July 2021
Apostolos Chalkis introduces dingo, a package for the analysis of metabolic networks, on which he worked as part of this Tweag fellowship.
8 July 2021
What should the type of linear traverse be exactly?
1 July 2021
Building OCaml projects with the new Bazel ruleset, OBazl
23 June 2021
Deconstructing the various uses of type classes.
15 June 2021
21 May 2021
Announcing a simulator for Tenderbake
23 April 2021
Tweag is looking for interns who want to contribute to Ormolu.
15 April 2021
How to use lenses and other optics within an Arrow-based framework.
8 April 2021
Define effect interpreters dynamically using reflection
26 March 2021
Incubating the Haskell Foundation during 2020.
25 March 2021
Discussion on using Bazel with inline-java
18 March 2021
A dive into Nickel's gradual type system, which mixes dynamic and static typing
4 March 2021
Better Go packaging with Gomod2nix
25 February 2021
Understanding monads in OCaml: mixing promises and errors
17 February 2021
10 February 2021
Announcing linear-base, a standard library for linearly typed Haskell programs.
5 February 2021
29 January 2021
A call to action to improve GHC's performance via a paid internship
22 January 2021
7 January 2021
How to break encapsulation and import a hidden value in Haskell.
16 December 2020
Trustix aims at enhancing trust in software binaries and improve reproducibility tracking using distributed binary caches.
3 December 2020
An applicative functor to define shrinkers
25 November 2020
Why Template Haskell is hard for cross compilation and how Asterius does it
18 November 2020
Why wasn't Nix built with a content-addressed store?
11 November 2020
Destinations give you control over your memory allocations, and linear types make them pure.
28 October 2020
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.
22 October 2020
9 October 2020
7 October 2020
Summary of the Tweag open source fellowship work related to ghcide
30 September 2020
Bazel gains support for creating fully statically linked Haskell binaries with rules_haskell and rules_nixpkgs.
23 September 2020
Meet Lagoon, a new open source tool for centralizing and querying semi-structured datasets.
16 September 2020
10 September 2020
Why content-addressability is desirable for Nix.
20 August 2020
What do we need to focus on to increase adoption of Nix?
12 August 2020
Learn how to use Nix to create highly reproducible Python builds that are aware of native dependencies.
6 August 2020
Learn about Hamiltonian Monte Carlo, and how to implement it from scratch.
31 July 2020
How to manage NixOS systems using Nix flakes.
28 July 2020
The second call for projects for the Tweag Open Source Fellowship is open and brings financial support and mentorship for Open source contributors.
13 July 2020
Announcement of the upcoming QualifiedDo language extension.
8 July 2020
How to setup a Buildkite-based CI for Nix projects with workers running on GCP.
29 June 2020
How we ensured that the implementation of random v1.2 produces higher quality random numbers than v1.1.
25 June 2020
How Nix flakes enable caching of evaluation results of Nix expressions.
19 June 2020
Looking back at the journey which brought us there, and forward to what still lies ahead.
18 June 2020
How Nix is collaborating with Software Heritage for long-term software reproducibility.
11 June 2020
Benchmarks of inline-java and a discussion of its performance trade-offs.
5 June 2020
Tweag introduces our first cohort of Open Source Fellows.
25 May 2020
An introduction to Nix flakes and a tutorial on how to use them.
6 May 2020
How to build a complete Haskell project with Bazel.
23 April 2020
How to derive instances via arbitrary isomorphisms.
16 April 2020
Imprecise, synchronous, asynchronous exceptions: what do they mean, and what to do with them.
9 April 2020
How to set up a remote Bazel cache, and why it is a good idea.
2 April 2020
This blog post describes the tradeoffs of the choice between eager and lazy instantiation of type variables in GHC.
12 March 2020
During my internship, I implemented the explicit specificity proposal to make GHC type signatures complete.
5 March 2020
Peirce divides reasoning into three complementary processes: deduction, abduction and induction. In this post, I will show how these logical processes relate to software.
26 February 2020
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.
19 February 2020
A primer on the interaction between linear types and exceptions in Haskell.
14 February 2020
The first call for the new Tweag Open Source Fellowship is open. It offers financial support and mentorship to open source contributors.
6 February 2020
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.
30 January 2020
This post describes a profiling technique for Haskell codebases that yields faithful results and is well adapted to large repositories.
16 January 2020
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.
9 January 2020
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.
19 December 2019
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.
28 November 2019
How to use the Makam metalanguage to implement an executable formal semantics for a simple language.
21 November 2019
Learn how Nix's new post-build hooks feature can automatically sign and upload artifacts to a binary cache in a trusted way.
8 November 2019
Here's Part 2 in Tweag's Series about Bayesian modeling in Haskell with the monad-bayes library.
30 October 2019
We're happy to announce the first release of Porcupine, an open source framework to express portable and customizable data pipelines.
25 October 2019
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.
11 October 2019
We're happy to announce the first release of Ormolu, a formatter for Haskell source code.
9 October 2019
Bazel gets native support for third-party Haskell libraries and building Cabal packages since the 0.10 release of rules_haskell.
25 September 2019
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.
20 September 2019
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`.
12 September 2019
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.
6 September 2019
People keep asking me, “What's the point of Haskell, why do you folks even use it?”. How can you answer this?
1 August 2019
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.
17 July 2019
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.
27 June 2019
27 May 2019
9 May 2019
10 April 2019
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?
3 April 2019
28 March 2019
20 March 2019
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.
11 March 2019
7 March 2019
28 February 2019
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.
20 February 2019
13 February 2019
6 February 2019
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.
23 January 2019
20 December 2018
12 December 2018
4 October 2018
12 September 2018
10 July 2018
21 June 2018
29 May 2018
25 April 2018
17 April 2018
29 March 2018
15 March 2018
8 March 2018
28 February 2018
8 February 2018
5 February 2018
21 December 2017
29 November 2017
16 November 2017
10 November 2017
1 November 2017
27 October 2017
19 October 2017
12 October 2017
5 October 2017
27 September 2017
22 September 2017
15 September 2017
6 September 2017
31 August 2017
24 August 2017
17 August 2017
9 August 2017
3 August 2017
1 August 2017
27 July 2017
10 July 2017
23 May 2017
18 May 2017
13 March 2017
17 October 2016
20 June 2016
25 February 2016
9 December 2015
8 September 2015
