bencope.land

Adaptability

In software development, the lure of the latest fad can be intoxicating. Whether it's an influential thought leader extolling the virtues of their favorite project management methodology, or the notion that enterprise software must be built with the hot language or framework, it's easy to find ourselves swept up in

ruminations

Abstraction, Again

In normal life situations there is always the possibility that something will get in the way of logic working perfectly. We might think that, logically, one plus one is always two, but in real life some aspect of the objects in question might get in the way. If someone gives

ruminations

Listening

When you are listening to the stories of accomplished men and the like, you should listen with deep sincerity, even if it's something about which you already know. If in listening to the same thing ten or twenty times it happens that you come to an unexpected undertstanding, that moment

react

React and Functional Programming

💡As I was planning this post, I looked around to see if anyone else had written on this and indeed someone has in this this post, and I recommend it. I decided to add to the topic rather than restating what was said there. The introduction of hooks in React

functional programming

Functional Basics: First Class Functions

In functional programming, the concept of first-class functions is fundamental. A function is considered to be a first-class citizen if it can be treated like any other value. This means that, similar to other values, functions can be assigned to variables, stored in data structures, passed as arguments to other

F#

Ray Tracer Challenge in F#

Notes from my README. This repository is a for-fun project I'm working on as I have some free time. I'm going through Jamis Buck's book ray tracer challenge, which is a language-agnostic book on how to build a ray tracer, guiding primarily through cucumber-style TDD test cases. F# Implementation This

functional programming

Functional Basics: Expressions

The journey to master functional programming involves shifting one's approach of even the simplest problems. It is a different paradigm after all. But don't be intimidated, because this journey is best travelled by embracing small shifts in thinking. Unlearning small things and learning other (perhaps smaller) things. Previously we looked

functional programming

Functional Basics: Identity Function

The identity function is an unassuming little function with a signature of 'a -> 'a. It returns the value of the argument it's given. At first glance it can seem rather pointless but it serves a purpose in both practical and theoretical contexts. The identity function is probably the first

F#

Modeling Domain Logic With Algebraic Data Types

There are a number of ways one might approach designing the logic of a domain problem. Most enterprise software engineers may be accustomed to modeling the problem using object-oriented programming, where classes encapsulate behavior and data. In this approach, the design often reflects the use of various design patterns, such

F#

Mapping Database Values to Discriminated Unions for Domain-Driven Design

Let's explore two strengths of F# and their application in a typical enterprise app, using an example that is relevant to any subscription-based service - working with a user's subscription status in both the code and the database. The first strength is it's focus on the domain, and being able

F#

Composable Database Connection Middleware with Giraffe

If someone is new to Giraffe and approaching it with familiarity of the built-in .NET server utilities, then utilizing the compose combinator ( >=>) may take some getting used to. This post will explore using the compose combinator through utilizing it to supply http route handlers with a database connection. We will

ruminations

Abstraction

💡My thinking around this topic is influenced by Eric Normand's Lispcast episode on abstraction. Check it out, and his podcast. Abstraction is a common topic in programming discussions. You hear a lot about the right abstraction, the wrong abstraction; this level of abstraction or that level; leaky ones, bad ones,

F#

Domain-Driven Microservices with F#

It is well-known, or at least well-documented, that F# is an excellent language for doing type-driven development using domain driven design, although it may be less well known that F# is an excellent language for microservices. Indeed, microservices benefit greatly from F#'s typesystem - making it easy to focus

game development

Godot 4 and F#

Update: After beginning to make a game, it turned out not to be as straightfoward as this post implies. Primarily because Godot 4 requires that the C# class be a partial class extending the corresponding Godot entity. F# doesn't have a direct translation of partial classes as far as I

F#

Flutter State in F# with Fable and Redux

Fable 4.0 is on the horizon 🎉 and with it comes the ability to compile F# code to Dart. Although Fable 4 is still pre-release, the Dart compilation works great - so great that I was able to migrate the entirety of my Redux state management in a Flutter app

F#

Function Composition vs Pipelines

A composed function can be thought of as being more generalized than a pipeline, as a pipeline needs a value to start with while a composed function receives an argrument directly. let clickHandler (value: string) = value |> parse |> sanitize |> serialize |> sendPayload The function above takes an argument, then passes that argument

godot

.NET 6 in Godot 4 Alpha

It looks like the Godot 4 alpha will be getting .NET 6 soon, according to this recent news. This is pretty exciting. I look forward to trying it out and may end up doing a guide on setting up F# in Godot 4. I'm particularly interested to see how well

F#

Generate Signed S3 URL in F#

If you have a single page application, you may be wanting to upload files directly to S3 from the browser rather than using your own server side application as a middle man between the two. In F# this can be done with the Amazon S3 package Via dotnet cli: dotnet

functional programming

Function Application

Consider this function: let makeName (firstName: string) (lastName: string) = $"{firstName} {lastName}" Let's apply it different ways with and without pipes, and with and without partial application. Application without pipeline: let name = makeName "Bob" "Vila" Partial application without pipeline: let applyLastName = "Bob" let name = applyLastName "Vila" Partial application with pipeline: let

F#

.NET 6 Minimal API with F# and Giraffe

Here's my setup for an F# .NET 6 minimal API. Start by opening up the main modules we'll be using in Startup.fs (or Program.fs as I tend to name it). open System open System.Text open Dapper open Microsoft.AspNetCore.Builder open Microsoft.AspNetCore.Hosting open Microsoft.AspNetCore.

reactive programming

Reactive Programming - Tower Defense for Data

Following a reactive approach to development is like setting up defenses in a tower defense game. You set up your pipeline of operators, each with its own skill and its own preferred target - and that’s it. Allow the application to send in the events and watch the operators

react

RxJS for Functional State Management

Since it is bundled with Angular, RxJS does not tend to get much attention as a means to have state in a functional React application. However, RxJS is a powerful way to have state with little boilerplate and high resilience. It is light in boilerplate because it can achieve immutable,

functional programming

Isolating Unused, Nil Expressions in React

A functional-first approach to programming discourages a number of typical JavaScript practices, including some practices that are even typical for React. In particular, React conventions nudge us towards having unused expressions, and to have expressions that are nil (undefined or null) with its useEffect hook. Let's consider how to isolate

functional programming

Lambda Calculus and Arguments

Functions in the lambda calculus are always unary - they only take one argument. Functional programming is based on the lambda calculus, and it is useful to learn to appreciate unary functions. One useful way to train your brain to think functionally is, when you find yourself writing an n-ary

F#

Type-safe JavaScript Development with F# and Fable

F# is a suitable alternative to TypeScript for writing a JavaScript application with type-safety. But you also get the additional benefits of F#'s powerful type inference. TypeScript interface Person { firstName: string lastName: string } let people: Person[] = [ { firstName: 'John', lastName: 'Doe' }, { firstName: 'Jane', lastName: 'Doe' }, ] let names = people.map(({ firstName,