bencope.land

YAGNI and Building Good Practices into Your Architecture

In software development, the mantra “You Aren’t Gonna Need It” (YAGNI) serves to keep projects lean, avoiding features or complexity until absolutely necessary. But over my 16 years in development, I’ve noticed that when it comes to architecture, this mindset often backfires. Certain patterns - like asynchronous programming,

F#

Cross-Boundary ADTs

Modeling a domain with algebraic data types (ADTs) is a powerful, expressive way to design code that is both concise and readable. Too often, code that does too little with too many lines negatively impacts readability and maintainability. ADTs, when supported by a language, provide a way to do more

lambdakure

The Existential Pleasures of Software Engineering

Readers of this blog may have noticed an occasional, pithy post tagged "Lambdakure," where I delve into philosophical or allegorical musings. Slowly but steadily, I've been crafting a book inspired by Hagakure, aimed at the journeying programming Samurai. My hope is to capture the transformation from

lambdakure

Haiku

Through the skilled use of literary devices such as juxtaposition, haiku can convey more in 17 syllables or less than an entire paragraph of prose. The writer can encapsulate a moment's entire scene, allowing the reader to unpack it with vast interpretation - all within the confines of

functional programming

Stacks

A few stacks that come to mind for that next web app project. * Full stack Rust with WASM * Full stack F# with Fable and a typical JS library on front-end * Elixir with Pheonix * Gleam with Pheonix * Full stack F# with Bolero (F# WASM) * Any of the above backends with Flutter

dart

Finding Delight in Unfamiliar Languages

Sometimes, languages we are unfamiliar with end up being delightful. At one point, I opted to compile F# to Dart for a Flutter project rather than use Dart directly because certain tasks were more verbose than I desired. While F# compiled to Dart quite flawlessly and impressively, I later decided

ruminations

Crafting Integrity

Enrich Skilled trades should enrich lives indiscriminately. Hone your character as you hone your skills. Avoid exploiting, polarizing, or alienating. Embrace humility, uplift others, and foster community and inclusion. Protect the dignity of all. Genuine success is rooted in desiring others to succeed. Elevate There is nothing profound or praiseworthy

functional programming

Embracing Theory In Software

I recently read a social media post about a functional programming book, in which the author praised it for avoiding complex terms such as “referential transparency” and “category theory.” The rationale seemed to be that these terms could complicate discussions about programming unnecessarily, at least in discussions about the essentials.

functional programming

The Myth of OOP/FP Compatibility

It’s a common misconception that choosing between Object-Oriented Programming (OOP) and Functional Programming (FP) is a false dilemma, suggesting that practitioners can seamlessly integrate both paradigms. But this is like saying that stick-built homes and steel-built homes are compatible because they both end up looking the same, or that

ruminations

Empathy in Software Design

Designing for Real Life One of the books that have been most influential on my thinking in software design was not a book on technical design patterns or theory, but a book called Design for Real Life by Eric Meyer and Sara Wachter-Boettcher. The book talks about designing your software

F#

Choosing Elegance: The Case for F# in Application Development

This post is for Day 6 of F# Advent Calendar. We all know the go-to languages for most companies in application software development: Java, C#, TypeScript, and Python, to name a few. There's obviously nothing wrong with using these ubiquitous languages, but there's a tendency to

ruminations

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

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,

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

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)

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

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

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.

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,

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

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