queil.net

Weir: language impossible

Fri, 09 Oct 2026 13:15:21 +0200

TLDR: I’ve been making an experimental language: weir. Why? I wanted a fast, typed, functional, cross-platform shell scripting language.

What is weir? ¶

Weir is an interpreted, statically-typed functional language with syntax heavily inspired by F# but with the ergonomics of a shell language (see it in the showcase). Its main goal is scripting, but it also has a decent interactive mode. Weir is shipped as a single native binary (no runtime to install; on Linux it only needs glibc). It is available on all major platforms. The binary houses the runtime, the checker, the interactive REPL, the canonical formatter, and the LSP server. Additionally, there are integrations available for a few editors. Try it out.

Evaluate Nu for Scripting: can it beat F#?

Sun, 16 Feb 2025 12:26:30 +0000

TLDR: No, nushell as a scripting language is not strict enough for a functional programming zealot. It seems I am not the only one waiting for improvements: https://github.com/nushell/nushell/issues/11108.

The context ¶

I am far from the mainstream on my scripting habits. I’ve been using F# as a language of choice with a number of custom-built tools to improve the experience. It’s mostly ok but recently Nushell got my attention. Not really as a shell but as a scripting language. One can sense a strong Rust influence which is no surprise given the shell itself is indeed written in it. I wanted to determine if it could solve my pain points with F# and what the trade-offs would be.

Hot-reloading with busybox httpd

Thu, 19 Jan 2023 14:32:16 +0000

Intro ¶

I’ve been recently working on a simple static website¹. I quickly noticed previewing it by browsing index.html is far from perfect. I needed a local server to host it. Ubuntu comes with busybox httpd by default so I decided to give it a go.

The server can host files form the current dir (-f makes it run in foreground rather than as a daemon):

busybox httpd -f -p 8090

It worked great until I got tired with hitting F5 to reload the page. I needed hot-reloading.

F# - an introduction for my colleagues

Wed, 14 Dec 2022 03:20:00 +0000

This article was originally published on the Account Technologies Tech Blog.

Motivation ¶

Having used quite a few programming languages in numerous projects(C#, Powershell, TypeScript, Groovy, and others), my favourite so far is F#. In this article, I want to present to you the unique traits of F# as a pragmatic functional-first language. Hopefully, this article is a mild and concise introduction to F# for people using other languages.

What is F# ¶

F# is a pragmatic general-purpose programming language. Its core design goals were:

Get IServiceCollection From Host Builder in .NET 6

Wed, 08 Jun 2022 08:35:29 +0100

Problem ¶

Neither .NET generic host’s HostBuilder nor IHost exposes IServiceCollection. You can resolve services via the IHost.Services property but there is no obvious way of accessing dependency registration metadata.

Solution ¶

It can be done using a custom service provider factory:

public class ExposeServiceCollectionFactory : IServiceProviderFactory<IServiceCollection>
{
    private DefaultServiceProviderFactory _defaultFactory = 
      new DefaultServiceProviderFactory();

    public IServiceCollection? ServiceCollection { get; private set; }

    public IServiceCollection CreateBuilder(IServiceCollection services)
    {
       ServiceCollection = services;
       return _defaultFactory.CreateBuilder(services);
    }

    public IServiceProvider CreateServiceProvider(IServiceCollection containerBuilder)
    {
       return _defaultFactory.CreateServiceProvider(containerBuilder);
    }
}

Then the factory can be used as follows:

var builder = new HostBuilder();
var factory =  new ExposeServiceCollectionFactory();

builder.UseServiceProviderFactory(factory);

// your configuration here

builder.Build();

var services = factory.ServiceCollection;

Console.WriteLine($"Got {services.Count} services here");

Why would you need that ¶

Usually you wouldn’t. It may come handy when you have a library consuming an IServiceCollection but you have lots of extensions methods for IHostBuilder rather than IServiceCollection. This way you can reuse your extension methods and pass the resulting IServiceCollection to the library.

Gmox Grpc Mock Server

Sun, 26 Dec 2021 13:06:58 +0000

TLDR: I created Gmox - a .NET-friendly gRPC mock server.

What is Gmox ¶

It is a gRPC mock server similar to grip-mock but written in F# and distributed as a dotnet cli tool and a dotnet template.

Why create one if other implementations already exist ¶

I wanted to create something easy to use for (my fellow- and all other) .NET developers.

I had the following scenarios in mind:

Development - enable developers to quickly spin up a mock server instance from local proto files.
Testing - enable testers to deploy a mock server as a part of a test scenario and control it during a test run.

Also I had the following requirements:

Dependency Trees With Fable and Sutil

Sat, 04 Dec 2021 15:04:33 +0000

Motivation ¶

One of my colleagues has recently mentioned they can hardly follow the dependency tree of YAML-configured systems like kustomize or GitLab CI. Both mentioned technologies enable configuration reuse via composition and inheritance. Obviously the reuse comes with an increased complexity which may be overwhelming for a newcomer. To lower the learning curve I wanted to create a tool that would allow an ad-hoc tree traversal and visualisation. I am excited as it requires reaching beyond my comfort zone. Straight to the realm of front-end.

Embedding F# Compiler: Fsc-Host NuGet

Sat, 16 Oct 2021 12:12:10 +0100

I have created a NuGet package that lets you easily use F# scripting in your apps.

NuGet: https://www.nuget.org/packages/Queil.FSharp.FscHost
Source: https://github.com/queil/fsc-host

What is this all about? ¶

In two previous posts (1, 2) I showed you how to host the F# compiler in your own applications. This time I wanted to reveal the result of those experiments. I wanted to enable F# scripting in a few of my apps. This requirement made me create the Fsc Host project. The goal was to create a light-weight reusable abstraction over FSharp.Compiler.Service focused on compiling scripts and consuming them by the hosting application. The NuGet package is available here. The project is still in the experimental phase (version 0) so the API and available features may change, (and the changes may be breaking so bear that in mind before using it in your projects).

Embedding F# Compiler: NuGet References

Fri, 04 Jun 2021 08:52:26 +0100

UPDATE: If you are looking for a ready to use solution please check out my fsc-host NuGet package. Also I wrote a blog post about it.

Intro ¶

In the previous post I showed how to extend an F# application with scripting capabilities. This time I want to extend the previous example with the #r directive support and resolving NuGet dependencies.

How to ¶

On high level we need to extract NuGet packages information from the script and pass it to the compiler as additional arguments. Before compiling we also need to dynamically load the referenced dlls to the host application. I first took the naive approach of parsing and extracting the directives from AST and feeding them into FSharpDependencyManager. It worked to an extent. Luckily, FsChecker comes with a built-in solution. We can use GetProjectOptionsFromScript and subsequently ParseAndCheckProject methods. That way we can retrieve DependencyFiles and extract resolved dlls’ paths.

Embedding F# Compiler

Sat, 29 May 2021 10:03:24 +0100

UPDATE: If you are looking for a ready to use solution please check out my fsc-host NuGet package. Also I wrote a blog post about it.

Motivation ¶

Embedded scripting is one of the ways of providing flexibility to compiled applications. It is not free from problems (performance penalty, security issues, additional tooling is required). But if your goal is a ceremony-free flexibility for the end-user then scripting is a very robust way¹ . F# comes with great capabilities in this area. I want to show you how you can extend your otherwise statically compiled program with scripting.

Docs for Your Open Source Project in 5 minutes

Sun, 25 Oct 2020 11:57:16 +0000

I’ve been using Hugo for a while and it also powers this blog. However, for my tiny Yzl project I wanted GitHub Pages docs that look like this. I’ve seen it in numerous open-source projects and I liked the material design look. If you like it too, please keep reading.

What is it? ¶

After a quick research I have found out that the tool is mkdocs and the theme I want is squidfunk/mkdocs-material. 2 minutes later I started playing with mkdocs. In the root of my repo I created docs folder with a placeholder index.md and ran:

My F# Toolbox for DevOps

Mon, 30 Mar 2020 20:50:33 +0100

My go-to free open-source packages I use in devops projects. Highly recommended if you enjoy rapid prototyping and like getting stuff working quickly.

Suave ¶

Project site | Apache 2.0 license

Suave is a simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition.

Suave is a swiss army knife for getting various types of APIs up and running without spending half a day digging through Microsoft documentation. It’s a set of low-level composable building blocks letting you put together a working thing.

Implicit Domain Models

Mon, 30 Mar 2020 08:20:57 +0100

Intro ¶

Whether you realise it or not, any non-trivial piece of code you write models a domain. Whether the model was deliberately designed and implemented or not, it is there. Its quality¹, or lack thereof, shapes the future².

Implicit domain models ¶

One of the results of writing code without a strong thought process are implicit domain models (IDMs). They’re are domain models that were neither deliberately designed nor expressed.

IDMs usually:

Dotnet Test and Jenkins

Thu, 24 Oct 2019 08:25:00 +0100

Problem ¶

How to get dotnet test results collected by Jenkins?

Solution ¶

Make dotnet test create logs:

dotnet test --logger trx

In console output you should now see messages like:

Results File: ...\TestResults\a_long_file_name.trx

Make Jenkins collect the results:

MSTest is the plugin that can consume trx files. Make sure it’s installed.

Add this line to your Jenkinsfile below your tests execution:
```
mstest testResultsFile:"**/*.trx", keepLongStdio: true
```

Notes ¶

You can run dotnet test on the whole solution. It generates a trx file per test project. The MSTest plugin collects all the files and creates an aggregated report accessible in Jenkins. This method is test-framework agnostic. I tested it with NUnit 3.

F# vs C#: Anonymous Records

Wed, 23 Oct 2019 08:40:07 +0100

Intro ¶

Anonymous types have been in C# since version 3.0 which makes it quite a mature and classic feature. On the contrary, anonymous records are in F# only since version 4.6 (which has only been released earlier this year). Both features serve a similar purpose. They enable developer to bundle a bunch of read-only properties into an ad-hoc inline-declared type.

Usage examples ¶

Full examples can be found here.

Projection ¶

Selecting a subset of available properties.

The Reasons to Run Code

Tue, 01 Oct 2019 07:48:37 +0100

There are only two reasons to run code:

return a value
cause a side-effect

Seamless Debugging of NuGet Packages

Wed, 14 Aug 2019 18:15:52 +0100

Introduction ¶

Sharing and reusing code between developers and teams has always been a serious challenge. Done badly it may gravely impede development and result with mediocre quality. Sharing source code per se has lots of problems on its own. Therefore, virtually every technology stack has a way of distributing versioned binaries instead. NuGet is the standard for sharing binaries in the .NET world. In open-source communities it’s natural to be able to view source code of a binary package. The next step is an ability to debug third-party binaries if debugging symbols are present. This, however, requires the source code to be downloaded and the debugger to be pointed to it. Source Link is an attempt to make the whole experience seamless. Essentially, it works by enriching packages’ metadata with source control specific information which then can be used on debug time to automatically download and display required source code.

Thinking

Sun, 16 Jun 2019 10:52:57 +0100

Thinking is the vital part of software development process. It raises questions. It is the fail fast principle taken to the extreme. I’d extend the popular “code the right thing” to “define what the right thing is, determine if code is the best solution in the first place, and then, if the answer is yes, build a solid mental model, and finally start coding the right thing”. Building a mental model may, (and often does), involve coding, and usually it’s an iterative process. Especially, when we explore an unknown domain and the model rapidly evolves. However, code is treated here as a thinking tool rather than the final product. It could be compared to sketching before putting any paint on the canvas. It’s easy and cheap to modify a sketch where is much more difficult to alter a ready painting.

Building Scala Projects for Ignorants

Sat, 23 Feb 2019 16:25:02 +0000

Why? ¶

As you know I am a rather .NET-orientated developer but with adoption of Kafka you realise lots of tools are written in Java or Scala. This time I needed to get built and deployed Remora - a Kafka lag monitoring tool from Zalando. In the Docker world you’d just use the provided Docker image. However, if you want an old-fashioned deployment you need to build it yourself.

The obvious you do not know ¶

You need to understand a couple of things before building Scala projects.

Pure Functions in C#

Tue, 27 Nov 2018 08:50:13 +0100

Intro ¶

Having some recent experience with F# I realised some of the functional programming principles could also be successfully used in C#. One could go completely crazy and create/use library like language-ext. However, I would like to focus on the way of writing code rather than utilizing any libraries. The idea I would like to introduce in this article is pure functions.

Pure has no side effects ¶

In a non-functional mindset there is a common misconception that side effects are something unwanted in good code. I guess it comes from the medical definition of side effects¹ where indeed any other than healing effects are undesirable. However, in the functional mindset we define side effects as changes to any external state. External i.e. not exclusively owned by the function. Here are a few examples of side effects:

Dotnet Templating Cheat Sheet

Tue, 10 Jul 2018 07:00:01 +0000

A few tips/examples on dotnet new templating. The snippets should be put in the template.json file of your template. All the text in UNDERSCORE_CASE you should replace.

Excluding files ¶

"sources":[{
    "modifiers":[{ 
                "exclude":["**/*.nuspec"]
                }]
        }]

Replacing text in file names ¶

"symbols":{
            "PARAM_NAME":{
                "type":"parameter",
                "description":"PARAMETER_DESCRIPTION",
                "replaces":"TEXT_TO_BE_REPLACED",
                "isRequired":true,
                "FileRename":"TEXT_TO_BE_REPLACED_IN_FILE_NAMES"
            }
        }

Input parameter ¶

"symbols":{
            "PARAM_NAME":{
                "type":"parameter",
                "description":"PARAMETER_DESCRIPTION",
                "replaces":"TEXT_TO_BE_REPLACED",
                "isRequired":true
            }
        }

Transformed parameter (text after the last dot) ¶

"symbols":{
            "PARAM_NAME":{
                "type":"derived",
                "valueSource":"SOURCE_PARAM_NAME",
                "valueTransform":"AfterLastDot",
                "replaces":"TEXT_TO_BE_REPLACED"
            }
},
"Forms":{
            "AfterLastDot":{
                "identifier":"replace",
                "pattern":"^.*\\.(?=[^\\.]+$)",
                "replacement":""
            }
    }

Transformed patrameter (to lower case) ¶

"symbols":{
            "PARAM_NAME":{
                "type":"derived",
                "valueSource":"SOURCE_PARAM_NAME",
                "valueTransform":"ToLower",
                "replaces":"TEXT_TO_BE_REPLACED"
            }
},
"Forms":{
            "ToLower":{
                "identifier":"lowerCase"
            }
    }

Generated port number parameter ¶

"symbols":{
            "PARAM_NAME":{
                "type":"generated",
                "generator":"port",
                "parameters":{
                    "low":LOW_PORT_NUMBER,
                    "high":HIGH_PORT_NUMBER
                },
                "replaces":"TEXT_TO_BE_REPLACED"
            }
        }

Webhook receivers in AspNetCore

Tue, 03 Jul 2018 20:07:00 +0100

DISCLAIMER: The code in this post is by no means production ready. Please treat it as a research rather that anything else. Also please note this is based on a preview of the functionality rather than on an official release.

Intro ¶

Although webhooks receivers didn’t make it into AspNetCore 2.1, the library is already in a pretty good shape. It works on top of the well-known AspNetCore.Mvc framework and greatly facilitates building your own receivers. In this article I am using the Microsoft.AspNetCore.WebHooks.Receivers.1.0.0-preview3-final version. The library comes with some out-of-the-box receivers for common webhooks providers like Dropbox, GitHub, WordPress, or Slack just to name the most popular. If you need to consume webhooks from those companies you’re already home. If you need a custom receiver please keep reading. Before we start coding I’d like to establish some background.

Kafka for Mere Mortals #2

Sun, 03 Jun 2018 22:30:50 +0100

I recommend to start with the previous part of the series before going ahead unless you have already read it.

Kafka as a distributed system ¶

Kafka is designed as a distributed system to achieve horizontal scalability, high availability (HA), and data redundancy. Horizontal scalability means we can keep adding more and more nodes to a cluster to handle virtually any imaginable load¹. High availability describes a system that is always operational even if some of its components fail or get disconnected. Data redundancy is employed to ensure there is no data loss or corruption.

Give it a try: Safe

Wed, 16 May 2018 07:46:11 +0100

Intro ¶

I’ve recently learnt about the SAFE Stack. It’s F# all the way from the client to the server side. It’s a fantastic news for back-end people (knowing F#). There is no need of learning intricacies of JavaScript. You can focus on productivity instead. In this post I just want to show you how quickly you can start developing.

First SAFE app ¶

Prerequisites ¶

.Net Core 2, Node.js, Yarn. Make sure you’ve got it all. Then just open shell and let’s type.

Finding references in C# code with Roslyn and F#

Tue, 20 Feb 2018 19:58:29 +0000

Introduction ¶

The most of .NET developers use Roslyn (the .NET Compiler) everyday. But apart from compiling code it comes with a versatile APIs used for syntax highlighting, analyzers, navigation tools just to name the most typical ones. I want to show you how to use it in your own tools. This time I want a tiny tool that finds all usages of a class¹ in a solution².

Let’s code ¶

I picked F# as my language of choice for this post. The code is easily translatable to C# though. All the code from the article you can access here.

Kafka for Mere Mortals #1

Sun, 01 Oct 2017 23:31:44 +0100

This series of posts is an attempt to explain what Apache Kafka is and to show some benefits of using it side by side with a relational database in a .NET (or really any) distributed solution. I am by no means expert in any of those technologies so take all of that with a pinch of salt. I am assuming you will have a basic knowledge of relational databases and some experience in building applications.

Slack Deployment Notifications

Sun, 17 Sep 2017 20:39:47 +0100

I’ve got a simple ASP.NET Core 2 web application setup hosted in AWS. My environment is built of 3 servers (build, web, and db). I want to minimize all AWS costs so I keep the servers off most of the time. Whenever turned on they get random public IP addresses from the AWS pool. I’ve got a really simple build and deployment process which apart from the usual elements also has the following step:

License

Sun, 17 Sep 2017 12:50:10 +0100

                             Apache License
                       Version 2.0, January 2004
                    http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

Definitions.

“License” shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.

“Licensor” shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.

“Legal Entity” shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, “control” means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.

About

Sat, 16 Sep 2017 23:11:23 +0100

Welcome to my personal professional blog. I am technical architect, developer, and researcher based in London. I am specialized in .NET (F#/C#), devops, and back-end development. Enthusiast of maths, linguistics, guitars, and notebooks.

Need for Blog

Sun, 10 Sep 2017 14:41:13 +0100

I’ve had a few attempts to start my own dev blog or website. However I would have always been pushed away by cumbersomeness of blogging platforms. To be fair I’ve never liked web interfaces. Needed a more dev-centric way of publishing own content. And finally I have discovered one that works for me (better later than never). It’s called static websites generation and it isn’t anything new whatsoever. Static websites are as old as the internet itself however thanks to evolution of web technologies (namely JavaScript, CSS, HTML, web browsers) it has been brought to a completely new level. The idea is to generate your web site in advance removing a need of a complex server environment (like databases or server-side processing). Obviously it has its limitations but I believe it works for blog-like websites very well.