Skip to main content

Why i changed the blog's name

This one's *not* be about programming... mostly. Ok, it is. It always is.

This is an explanation on why I changed the name I had for this blog. The previous name was officially Run or Debug, but now I called Left Fold. Why would you do that, you ask?

Well, the main story is because I hated the previous name but still I didn't have the courage (or the will) to change it. And truly, I didn't have a better name in mind... Until recently!

I started to learn F# recently and as a guy who comes mostly from C# a lot of concepts were new to me, and some were not new, I just didn't know their name. It has been quite a journey, as anyone who has the same background as me would understand. I jumped from a general OOP language to a non-pure functional language.

One of those concepts "learned" is called a left fold. I am aware it does exist in C# too, and it is all but new, but hear me out, I just never had thought about it this way. So, what the hell is a left fold after all? Let's dive in this surprisingly simple concept.

Think of a list of values. Let's say, a list of strings with the alphabet inside:

["a"; "b"; "c"; "d"; "e"; "f"; "g"; "h"; "i"; "j"; "k"; "l"; "m"; "n"; "o"; "p"; "q"; "r"; "s"; "t"; "u"; "v"; "w"; "x"; "y"; "z"]

The concept of fold is simply this: take an initial state and for each letter in that list produce a new state based on the letter. Then feed that state to the function along with the next letter and produce the next state. Let's see an example in C#:

Of course, everyone using Linq knows the Aggregate method. But really, how frequently do you use it? We use the variations surely... Sum, Max, Min, etc. But I never really thought about those methods in terms that they might be just a derivation from an underlying concept. And that concept is the left fold!

Let's look again at how it works, in simple terms:
  1. Start with a state. In the snippet above this state is an empty string implicitly, but there is another overload that accepts a seed state.
  2. Take that state and an item in the list, and execute the function passed in. The function should produce a new state.
  3. Repeat 2 for all items in the list.
Now let's define some of the LINQ methods in terms of Aggregate, just for kicks. This time we'll use a list of ints

So, you can see the usefulness of the concept now. In fact, many more Linq operators can be defined in terms of a left fold, those were just the most obvious ones. Of course, in the background they are actually not defined like that, but i'm getting a point across.

This is a big topic, but I don't want a big post, so let's call it a day.
TL;DR: I didn't like the previous name and I like this one because of how useful the actual concept is.

Comments

Popular posts from this blog

The repository's repository

Ever since I started delving into architecture,  and specifically service oriented architecture, there has been one matter where opinions get divided. Let me state the problem first, and then take a look at both sides of the barricade. Given that your service layer needs to access persistent storage, how do you model that layer? It is almost common knowledge what to do here: use the Repository design pattern. So we look at the pattern and decide that it seems simple enough! Let's implement the shit out of it! Now, let's say that you will use an ORM - here comes trouble. Specifically we're using EF, but we could be talking about NHibernate or really any other. The real divisive theme is this question: should you be using the repository pattern at all when you use an ORM? I'll flat out say it: I don't think you should... except with good reason. So, sharpen your swords, pray to your gods and come with me to fight this war... or maybe stay in the couch?

The evolution of C# - Part III - C# 2.0 - Iterators

It's been a while since i wrote the last post, but i did not forget my purpose of creating a series that shows the evolution of C#. Today i came here to talk about one of the most useful features of C#, even if you dont know you're using it. Let's talk about iterators ! What is an iterator? For those of you who didn't read about the iterator pattern somewhere in the internet or in the "Gang of Four" book, you can read a description  here . The iterator is a class/object/whatever which knows how to traverse a structure. So, if you have a list or collection of objects, an iterator would have the knowledge of how to traverse that collection and access each element that it contains. The iterator is a well known design pattern and is behind many of the wonderful that we have nowadays in .NET (Linq comes to mind). Why is it a feature? Truth be told, an iterator is a concept well known way before .NET even existed. Being an OO Design Pattern, the iterator has

My simplest and most useful type

I have been doing some introspection on the way I write code to find ways that I need to improve. I consider this a task that one must do periodically so that we keep organized. There is a very, very simple problem that occurs in every application I know: How to return the results of an operation to the user? I've seen many implementations. Some return strings, some throw exceptions, some use out parameters, reuse the domain classes and have extra properties in there, etc. There is a myriad of ways of accomplishing this. This is the one I use. I don't like throwing exceptions. There are certainly cases where you have no choice, but I always avoid that. Throughout my architectures there is a single prevalent type that hasn't changed for years now, and I consider that a sign of stability. It is so simple, yet so useful everywhere. The name may shock you, take a look: Yes, this is it. Take a moment to compose yourself. Mind you, this is used everywhere , in every