https://davidraab.github.io/ Recent content on David Raab Hugo -- gohugo.io en-us Fri, 26 Dec 2025 00:00:00 +0000 https://davidraab.github.io/posts/gos-error-handling/ Fri, 26 Dec 2025 00:00:00 +0000 https://davidraab.github.io/posts/gos-error-handling/ Recently i tried out some Go. There are some good parts on Go that I think more languages should do, and some bad parts. Go’s Error Handling is something i consider better than in most other langauges, bad still bad enough looking on it from a function-programmer perspective. So let’s dig deeper. Why do I think Go’s Error handling is better, let’s say compared to C. At least Go’s tries to be a system language competing with C. https://davidraab.github.io/posts/why-i-hate-templating-languages/ Mon, 21 Apr 2025 00:00:00 +0000 https://davidraab.github.io/posts/why-i-hate-templating-languages/ In the past I have worked a lot in web-development. This goes back to the early 2000 when web-sites was primarily just CGI scripts and didn’t used any JavaScript at all. Back then JavaScript also was mostly very slow as most Browser interpreted JavaScript. Back in that old times every click on a button, link and so on was a full request to the browser and a full new page has to be generated on the server side. https://davidraab.github.io/posts/quick-useless-classes/ Sat, 01 Feb 2025 00:00:00 +0000 https://davidraab.github.io/posts/quick-useless-classes/ Here is a quick reminder. When you have a class/object that only has a single method. 1 2 3 4 5 6 7 8 9 my $obj = Class->new( arg1 => "whatever", arg2 => 10, ); my $result = $obj->one_method( arg3 => [], arg4 => {}, ); then just make a single function out of it. 1 2 3 4 5 6 my $result = one_method( arg1 => "whatever", arg2 => 10, arg3 => [], arg4 => {}, ); this also works with multiple methods, but with just a single method it defenitely should just be a single function. https://davidraab.github.io/posts/sq-counting-to-1-billion-twice/ Mon, 30 Dec 2024 00:00:00 +0000 https://davidraab.github.io/posts/sq-counting-to-1-billion-twice/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 #!/usr/bin/env perl use 5.036; use utf8; use open ':std', ':encoding(UTF-8)'; use Sq; use Sq::Sig; # functional-style my $countup = assign { my $bill1 = Seq->range(1,1_000_000_000); my $is_even = sub($x) { $x & 1 }; Seq::flatten_array( Seq::zip( Seq::filter($bill1, $is_even), Seq::remove($bill1, $is_even), ) ); }; run(sub { $countup->iter(sub($x){ if ( $x % 10_000 == 0 ) { print "First: $x\n"; } }); }); # procedural / oo-style my $bill1 = Seq->range(1,1_000_000_000); my $is_even = sub($x) { $x & 1 }; my $evens = $bill1->filter($is_even); my $unevens = $bill1->remove($is_even); my $zip = $evens->zip($unevens); my $flatten = $zip->flatten_array; run(sub { $flatten->iter(sub($x){ if ( $x % 10_000 == 0 ) { print "Second: $x\n"; } }); }); sub run($f) { my $start = time(); $f->(); my $stop = time(); printf "Time: %d seconds\n", $stop; } Source Code for Example https://davidraab.github.io/posts/sq-release-0-6/ Tue, 24 Dec 2024 00:00:00 +0000 https://davidraab.github.io/posts/sq-release-0-6/ I am now bumping the version to 0.7, so this commit will be the last to define 0.6 or how Perl versions are used for this as 0.006. I cannot provide a full Changelog and I also do not care. I am working on this alone and cannot provide full professional support for everything. If someone else want to have a changelog he can go through the commit and create it itself. https://davidraab.github.io/posts/code-as-data/ Sun, 22 Dec 2024 00:00:00 +0000 https://davidraab.github.io/posts/code-as-data/ I have the following type definition. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 my $album = t_hash( t_with_keys(qw/artist title tracks/), t_keys( artist => t_str(t_min 1), # string must have at least 1 char title => t_str(t_min 1), tracks => t_array( t_min(1), # Array must have at least 1 entry t_of( t_hash( # All entries must be hashes t_with_keys(qw/name duration/), t_keys( name => t_str, duration => $duration)))))); this is code that builds a function that you can run and type check against any value. https://davidraab.github.io/posts/moose-traits-vs-sq/ Wed, 04 Dec 2024 00:00:00 +0000 https://davidraab.github.io/posts/moose-traits-vs-sq/ Moose Traits vs. Sq (Explicit language) Did you ever hear of the Law of Demeter in object-orientation? Here is the idea behind it. Let’s assume we have a class, and that class has a property named options. This options is an array. In procedural or functional programming we would just access that array and do whatever we wanna do with it. But somehow in object-orientation land people think this is bad. https://davidraab.github.io/posts/benefits-of-dynamic-typing/ Thu, 28 Nov 2024 00:00:00 +0000 https://davidraab.github.io/posts/benefits-of-dynamic-typing/ This is not a post about static typing vs. dynamic typing. In the several past years I have worked with both and see advantages and disadvantages in both dynamic and static typing. While this might be an interesting topic on its own, this is maybe for a future post. No matter what you like or dislike more, some languages are built from the core being either static or dynamic typed. Perl, including other languages like Python, Ruby, JavaScript, Lisp, Lua, … are built as a dynamic typed language. https://davidraab.github.io/posts/algorithms-filtering-an-array-benchmarks/ Sat, 12 Oct 2024 00:00:00 +0000 https://davidraab.github.io/posts/algorithms-filtering-an-array-benchmarks/ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 #! https://davidraab.github.io/posts/algorithms-filtering-an-array/ Mon, 07 Oct 2024 00:00:00 +0000 https://davidraab.github.io/posts/algorithms-filtering-an-array/ Let’s say we wanna filter an Array. In general that means we want to run some constraint on every element. The goal is to keep only the elements that fulfills the constraint. This is a very easy task, and yet there are multiple ways on how todo that. Each solution offers different advantages and disadvantages. But first let’s pick a concrete example. We just have an array of integers and we wanna keep only those that are even. https://davidraab.github.io/posts/data-vs-interfaces/ Tue, 17 Sep 2024 00:00:00 +0000 https://davidraab.github.io/posts/data-vs-interfaces/ Intro When we face a problem, then we must admit one thing, there are always different kind of approaches how we can solve something. And on top of that, different kind of approaches have different kind of advantages and disadvantages. Whatever you do, you will never find a perfect solution in the sense that this solution is best in everything. Usually every advantage has its opposite disadvantage. For example for solving a problem there are usually different algorithm out there. https://davidraab.github.io/posts/interfaces-in-functional-programming/ Wed, 04 Sep 2024 00:00:00 +0000 https://davidraab.github.io/posts/interfaces-in-functional-programming/ Recently I worked with Raylib a graphics library for doing/learning game development. When I created multiple small demos there was one thing I wanted todo across multiple projects. I wanted to drag game objects on the screen. I already solved that problem once so now I just needed to create a general function that allowed me to drag any kind of object, instead of writing a specific solution again and again. https://davidraab.github.io/posts/gamedev-implementing-a-hash-like-structure/ Wed, 24 Jul 2024 00:00:00 +0000 https://davidraab.github.io/posts/gamedev-implementing-a-hash-like-structure/ What Is Recently I implemented my own data-structure to optimize the storage of my components in a game. Okay its more an architecture i am exploring not a real game at the moment. I just try to render and move as many things as possible while i try to keep frames per second as high as possible. For example rendering 10,000 boxes let them move in random directions, and change direction every second to a new random direction runs at 600 fps. https://davidraab.github.io/posts/debian-tool-purging-config-of-removed-packages/ Sat, 13 Jul 2024 00:00:00 +0000 https://davidraab.github.io/posts/debian-tool-purging-config-of-removed-packages/ In Debian the following “problem” sometimes arrives. Let’s say you install for example Apache2, you do something with it but shortly after you don’t need it anymore. By default Debian always keeps all configuration files alive. So after installing Apache2 once, you are left with some configuration files in /etc/apache2/. This is usually a good idea, because removing a package and re-installing shouldn’t delete all your configuration. But what do you do if you really want to delete the configuration because you really don’t need them anymore? https://davidraab.github.io/posts/oop-is-partial-application/ Mon, 10 Jun 2024 00:00:00 +0000 https://davidraab.github.io/posts/oop-is-partial-application/ In the past I spent a lot of time in different online forums, websites and so on. As I am interested in general about language design and learnt a lot of languages I also had many discussions with different programmers of different knowledge. As I started programming with QBasic and C I am also used to procedural programming. The same goes for Perl. As of Perl 5 (1994) it also contains object-oriented programming, but still some parts of it are procedural. https://davidraab.github.io/posts/example-f-list-is-anemic/ Thu, 06 Jun 2024 00:00:00 +0000 https://davidraab.github.io/posts/example-f-list-is-anemic/ In my previous article Anemic Domain Model: Data and behaviour should be separated I explain why you should stick to an Anemic Domain Model and which benefits it offers. In this article we look into F# to see how it applies there. F# has many built-in data-structures like many languages. One of the most used data-structure is the List data-structure. When you follow a typical object-oriented solution then maybe you would end up with a List class, maybe you will consider some data as private, because the way how to manage a list should be managed by the class. https://davidraab.github.io/posts/why-map-was-not-discovered-in-object-oriented-programming/ Wed, 05 Jun 2024 00:00:00 +0000 https://davidraab.github.io/posts/why-map-was-not-discovered-in-object-oriented-programming/ When I started Perl programming back around 2003 one thing that Perl had, what most language didn’t, was the existence of the map function. In today world of programming from JavaScript, C#, Java and so on, the concept nowadays is so common that nearly every language has it, and usually every programmers understands and use it. That was not always the case. I can remember when LINQ was introduced in C# how a lot of people was complaining how from know on C# would be a language that nobody else never can read or understand anymore. https://davidraab.github.io/posts/anemic-domain-model-data-and-behaviour-should-be-separated/ Tue, 04 Jun 2024 00:00:00 +0000 https://davidraab.github.io/posts/anemic-domain-model-data-and-behaviour-should-be-separated/ In the object-oriented world there is often a debate around the so called Anemic Domain Model. An Anemic Domain Model is when you clearly separate your data and your code. In object-orientation this is usually considered bad, but when you look at procedural or functional-programming things change. They are seen as good practice you should follow. So who is right? Rich Domain Model The opposite of an Anemic Domain Model is usually called a Rich Domain Model the idea of it goes as follow. https://davidraab.github.io/posts/functions-are-interfaces/ Thu, 30 May 2024 00:00:00 +0000 https://davidraab.github.io/posts/functions-are-interfaces/ When I started to learn C# around 2013 there were certainly new things I came into contact. Some of them had todo with the fact that I primarily used Perl, a dynamic typed language, but in some sense the language features of Perl were also far ahead of C# back then, leading to different solutions and how you use a language. Back at that time I realised that a lot of programmers were into a “newly” thing. https://davidraab.github.io/posts/learning-lisp-in-60-seconds/ Tue, 28 May 2024 00:00:00 +0000 https://davidraab.github.io/posts/learning-lisp-in-60-seconds/ Do you wanna learn Lisp? If yes, you come to the right place. Do you know how to call a function/procedure in most languages? Yes right, like this. 1 function(arg1, arg2, arg3) This syntax is used in C, C++, Perl, Python, Java, … you get it. In a Lisp language you just put the starting ( before the function call and remove the commas. 1 (function arg1 arg2 arg3) There you have it, you have learned 100% of the syntax of a Lisp language. https://davidraab.github.io/posts/perl-argument-aliasing/ Mon, 13 May 2024 00:00:00 +0000 https://davidraab.github.io/posts/perl-argument-aliasing/ Different to many other languages Perl has an aliasing feature when you pass arguments to a function. As an example let’s see the following code. 1 2 3 sub increment { $_[0]++; } As probably known, all values in Perl are put into the @_ array. But when you directly modify one of these elements, then the original values are modified. So executing the following. 1 2 3 4 5 6 7 my $x = 0; increment($x); say $x; increment($x); say $x; will print 1 and then 2. https://davidraab.github.io/posts/class-vs-hash/ Wed, 08 May 2024 00:00:00 +0000 https://davidraab.github.io/posts/class-vs-hash/ In my previous articles about object-orientation I explained how OO in general works. I used Perl for the explanation, as it doesn’t hide its itnernals like most other languages do. That’s Why I like Perl’s OO. Usually OO works that we define a mutable data-structure and pass it to a function that mutates it. So in some sense calling func($obj, $arg1) is the same as $obj->func($arg1). It’s just a different syntax and order we write, but the concept is the same. https://davidraab.github.io/posts/why-i-like-perls-oo/ Mon, 15 Apr 2024 00:00:00 +0000 https://davidraab.github.io/posts/why-i-like-perls-oo/ I started programming with QBasic and later C. While it was difficult to learn those languages back then (with no internet and just some books) nothing felt “out of place” for me. For example, when I learned about arrays the first time, it took some time to learn the concept of it, that it is a storage of multiple elements one after another. How it is used and what you can do with it. https://davidraab.github.io/posts/insanity-of-oo/ Sat, 16 Mar 2024 00:00:00 +0000 https://davidraab.github.io/posts/insanity-of-oo/ The insanity of Object-Oriented Programming I started programming back in the 1990s. My first language I learned was QBasic and after 2 days of learning it, i switched to C. Back in these days there was no Internet. Okay, it existed but was not so common as today. Most people still didn’t even had computers. I picked and learned C because when you got to the programming section in a store it was full of C books. https://davidraab.github.io/posts/perl-seq-seq-manual-fromsub/ Tue, 21 Nov 2023 00:00:00 +0000 https://davidraab.github.io/posts/perl-seq-seq-manual-fromsub/ Seq::Manual::FromSub A deeper explanation how Seq->from_sub works. THE PROBLEM You could write the following in Perl 1 Seq->wrap(1 .. 10_000_000) but it would be a bad idea. Perls range operator is non-lazy. When you call the above code perl will create an array with 10 Mio numbers and then pass that 10 Mio numbers to Seq->wrap. This is not only time-consuming, it will also use a lot of memory. Maybe with a bigger number your program or your computer could even crash with out of memory. https://davidraab.github.io/posts/perl-sq-bind-and-cartesian/ Mon, 20 Nov 2023 20:00:00 +0000 https://davidraab.github.io/posts/perl-sq-bind-and-cartesian/ The cartesian function returns the Cartesian Product. The Cartesian Product is the combination of all possible values. 1 2 3 4 5 my $data = Seq::cartesian( Seq->wrap(qw/clubs spades hearts diamond/), Seq->wrap(qw/7 8 9 10 B D K A/), )->to_array; Calling to_array will evaluate the expression and generates the following Perl data-structure. 1 2 3 4 5 6 7 8 9 10 [ ['clubs' ,'7'],['clubs' ,'8'],['clubs' ,'9'],['clubs' ,'10'], ['clubs' ,'B'],['clubs' ,'D'],['clubs' ,'K'],['clubs' ,'A' ], ['spades' ,'7'],['spades' ,'8'],['spades' ,'9'],['spades' ,'10'], ['spades' ,'B'],['spades' ,'D'],['spades' ,'K'],['spades' ,'A' ], ['hearts' ,'7'],['hearts' ,'8'],['hearts' ,'9'],['hearts' ,'10'], ['hearts' ,'B'],['hearts' ,'D'],['hearts' ,'K'],['hearts' ,'A' ], ['diamond','7'],['diamond','8'],['diamond','9'],['diamond','10'], ['diamond','B'],['diamond','D'],['diamond','K'],['diamond','A' ], ] The implementation of Seq::cartesian. https://davidraab.github.io/posts/seq-in-combination-with-io/ Mon, 20 Nov 2023 01:00:00 +0000 https://davidraab.github.io/posts/seq-in-combination-with-io/ In one of my programs I already use my module. This program creates a new test-file in the ’t’ folder from a template. From all files in that directory I want to automatically pick the next highest number. I don’t want to search for the number myself. So here is how i read all files from disk and only pick files matching the pattern “%d-$title.t”. Then i want the maximum number. https://davidraab.github.io/posts/perl-seq-module-bind-flatten/ Sun, 19 Nov 2023 02:00:00 +0000 https://davidraab.github.io/posts/perl-seq-module-bind-flatten/ I implemented the bind function in my Perl Seq Module. bind is a very useful function. For example here is flatten that I implemented with it. flatten Flatten takes a sequence of sequences and returns a single sequence. 1 2 3 4 5 6 my $flattened = Seq->wrap( Seq->wrap(1,1), Seq->wrap(2,3,5,8,13), ) ->flatten; This is how a non-lazy Perl implemenation would look like: 1 2 3 4 5 6 7 8 9 sub flatten($aoa) { my @flattened; for my $outer ( @$aoa ) { for my $inner ( @$outer ) { push @flattened, $inner; } } return \@flattened; }; Using it looks very similar. https://davidraab.github.io/posts/shape-of-my-heart/ Sun, 19 Nov 2023 00:00:00 +0000 https://davidraab.github.io/posts/shape-of-my-heart/ Here are two programs that produces the same result. This is something I would have written without my Sq module. 1 2 3 4 5 6 [ (map { [clubs => $_ ] } qw/7 8 9 10 J Q K A/), (map { [spades => $_ ] } qw/7 8 9 10 J Q K A/), (map { [hearts => $_ ] } qw/7 8 9 10 J Q K A/), (map { [diamond => $_ ] } qw/7 8 9 10 J Q K A/), ] With my module, i now can write the same in this way. https://davidraab.github.io/posts/assigning-variables/ Sat, 18 Nov 2023 02:00:00 +0000 https://davidraab.github.io/posts/assigning-variables/ This is how you assign a value from right to left. 1 2 my $x = 1; ... this is how you assign a value from left to right. Perl 1 do_something(12, sub ($x) { ... }); JavaScript 1 do_something(1, function(x) { ... }) F# 1 doSomething 1 (fun x -> ... ) https://davidraab.github.io/posts/sq-fibonacci-with-seq/ Sat, 18 Nov 2023 01:00:00 +0000 https://davidraab.github.io/posts/sq-fibonacci-with-seq/ Hi there, I am developing a new Perl module to bring a lazy Sequence to Perl. It should provide the functionaly you see in C# LINQ or Java 8 Stream. The origin of those interfaces comes from functional programming. Thus i decided to primarily pick the F# API and port it to Perl. I already implemented a useful set of functions. Here is an example of the module and what you can do with it. https://davidraab.github.io/posts/searching-for-a-linux-command/ Sat, 04 Nov 2023 00:00:00 +0000 https://davidraab.github.io/posts/searching-for-a-linux-command/ Lately I wanted to search for a Linux Command. I didn’t knew the exact command, only that there must be a “wacom” in it. A configuration tool to set some more details of my wacom tablet. So I thought. Hey, just collect all binary files in all the directores in the PATH Environment of Linux. The Path environment is divided with colons. Just let me give it a Regex it can match against. https://davidraab.github.io/posts/object-oriented-programming-in-c/ Wed, 01 Nov 2023 00:00:00 +0000 https://davidraab.github.io/posts/object-oriented-programming-in-c/ Let’s do object-oriented programming in C. First of I am creating an easy example for an Vector2 type. To define a Vector2 in C we use a struct. 1 2 3 4 struct Vector2 { int X; int Y; }; When you know C#, you are already familiar with a struct. A struct is a value-type in C. It always gets copied as a whole. In C# we have a class that is a reference-type but this doesn’t exist in C. https://davidraab.github.io/posts/creating-a-real-enum-type-in-perl/ Sun, 29 Oct 2023 00:00:00 +0000 https://davidraab.github.io/posts/creating-a-real-enum-type-in-perl/ In my previous article about Metaprogramming in Perl I show how to implement an enum() function that creates real special values that are distinct from each other. When I called enum('red', 'green', 'blue') it created two functions for every passed string. red() and is_red() for the red string. red() returns the special value and is_red($value) checks if $value is our special value. But currently it does not completely satisfy being an enum. https://davidraab.github.io/posts/meta-programming-in-perl/ Thu, 26 Oct 2023 00:00:00 +0000 https://davidraab.github.io/posts/meta-programming-in-perl/ In my last article about Special Values in Perl I explained how we can create true distinct values that can be safely distinguished by other values. The final result looked like this: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 use Scalar::Util qw(refaddr reftype); # Special values Red, Green and Blue { # <-- this creates a new lexical-scope my ($red, $green, $blue) = ([], [], []); sub red { $red } sub green { $green } sub blue { $blue } my $is_color = sub { my ($source, $color) = @_; my $type = reftype($source) // ''; return ( $type eq 'ARRAY' and refaddr($source) == refaddr($color) ) ? https://davidraab.github.io/posts/special-values-in-perl/ Wed, 25 Oct 2023 00:00:00 +0000 https://davidraab.github.io/posts/special-values-in-perl/ Sometimes in programming we want to create special values that are distinct to anything else. Consider the following problem. We want to create a print_colored function, that can be given special values to change the terminal color. Here is one way to do it: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 use Term::ANSIColor qw(color); my $red = "RED"; my $green = "GREEN"; my $blue = "BLUE"; sub print_colored { for my $line ( @_ ) { print(color('red')) && next if $line eq $red; print(color('green')) && next if $line eq $green; print(color('blue')) && next if $line eq $blue; print $line; } } print_colored($green, "red", "\n", $blue, "foo\n"); This solution successfully prints the string “red” in the green color and “foo” in the blue color. https://davidraab.github.io/posts/perl-vs-javascript-scalar-and-list-context/ Fri, 20 Oct 2023 00:00:00 +0000 https://davidraab.github.io/posts/perl-vs-javascript-scalar-and-list-context/ Something I like in Perl, and also dislike sometimes, is Perl distinction between Scalar- and List Context. Something I haven’t seen in any other language so far. In Perl any function call can happen in two different context. And depending on the context a function can return different things, or even behave differently. But it also effects how arguments are passed to a function. Let’s see an example. I want to write an easy sum function that sums up all numbers given to it. https://davidraab.github.io/posts/installing-perl-with-perlbrew/ Fri, 17 Feb 2023 00:00:00 +0000 https://davidraab.github.io/posts/installing-perl-with-perlbrew/ Today every Linux system mostly already ships Perl including a lot of modules. While this can be totally fine sometimes maybe you want to switch to a newer Perl version. Or maybe even an older version to test a module with an older Perl version for compatibility? perlbrew is a tool that helps installing multiple Perl environments and gives you the ability to switch between them. Installing your own Perl also means you don’t mess with the system installed Perl and you are able to install any new module directly from CPAN. https://davidraab.github.io/posts/closures-in-fsharp-csharp-perl-javascript-and-racket/ Wed, 15 Feb 2023 00:00:00 +0000 https://davidraab.github.io/posts/closures-in-fsharp-csharp-perl-javascript-and-racket/ Today, more and more languages supports functions as first-class values. This means a function is just a value like any other. You can pass functions as arguments to functions, but you are also able to create functions and return them from functions. Whenever this is done we have to think about the life-time of variables. Usually all variables are lexical scoped. Consider the following example. F# C# Perl JavaScript Racket 1 2 3 let add10 y = let x = 10 x + y 1 2 3 4 public static int Add10(int y) { var x = 10; return x + y; } 1 2 3 4 sub add10($y) { my $x = 10; return $x + $y; } 1 2 3 4 function add10(y) { const x = 10; return x + y; } 1 2 3 4 (define (add10 y) (define x 10) (+ x y) ) In the example the variable x is created only temporary when the function is being executed. https://davidraab.github.io/posts/what-is-dependency-injection/ Wed, 11 Jan 2023 00:00:00 +0000 https://davidraab.github.io/posts/what-is-dependency-injection/ On Reddit i came to a question about someone who had problems understanding Dependency Injection. He provided the following code. 1 2 3 4 5 6 7 8 9 10 11 12 public class Wheel { public Wheel() {} public void moveleft() {} } public class Car { private Wheel wheel; public Car (Wheel wheel) { this.wheel = wheel; } } The question is: Is this usage of Wheel in Car Dependency injection? https://davidraab.github.io/posts/perl-regex-parsing-with-g-option/ Sat, 07 Jan 2023 00:00:00 +0000 https://davidraab.github.io/posts/perl-regex-parsing-with-g-option/ Perl regexes have the /g modifier that is worth knowing about, as you can do a lot of advanced things with this modifier. But here are the basics first. Context First we need to understand that Perl has two different contexts and in both contexts the /g modifier works differently. List context Let’s see list context first. We can enforce list context by assigning to an array. Without the /g option a regex just finds its first match and just returns it. https://davidraab.github.io/posts/are-dynamic-typed-languages-really-faster-to-develop/ Fri, 02 Dec 2022 00:00:00 +0000 https://davidraab.github.io/posts/are-dynamic-typed-languages-really-faster-to-develop/ On Reddit i came about a discussion of dynamic typed (functional) languages. A user suggested that in a dynamic typed language it might be easier to return different types for a function call and thus overall the development can be faster. He concluded. Having not to deal with types in that way when you refactor or build a system makes you significantly faster. Combine that with a proper testing approach and you have a reason to use dynamically typed languages. https://davidraab.github.io/posts/map-operates-on-functions/ Thu, 27 Oct 2022 00:00:00 +0000 https://davidraab.github.io/posts/map-operates-on-functions/ map operates on functions not on data-types like list. When I started learning F# I had some problems understanding the map function. Don’t get me wrong. As a Perl programmer map is built into the core language (long before other languages adopted the idea) and I used and understanded it very well in Perl. This map is the same as List.map that I also immediately understood. But in F# you will encounter Result. https://davidraab.github.io/posts/optional-generic-equality/ Tue, 25 Oct 2022 00:00:00 +0000 https://davidraab.github.io/posts/optional-generic-equality/ Lately I implemented my own immutable Queue and came upon a problem implementing equality for it. The problem goes like this: You want a generic data-type that supports equality. But it only should support equality if the generic type also supports equality. Seems a little bit weird? But this is actually a common problem in F# that is already solved without that you probably even noticed that this is a problem. https://davidraab.github.io/posts/understanding-fold/ Sun, 19 Mar 2017 00:00:00 +0000 https://davidraab.github.io/posts/understanding-fold/ A very important function in List-processing is the List.fold function. List.fold is a very powerful function that gives you a lot of flexibility to do any kind of list transformation. The disadvantage is that this kind of power makes understanding List.fold a lot harder. In this article we look at some visualizations to better understand List.fold. First we need to understand how we visualize a function. A function has some inputs and one output and we visualize it as a box with the inputs on the top and the output on the bottom. https://davidraab.github.io/posts/variable-arguments-in-fsharp/ Mon, 13 Mar 2017 00:00:00 +0000 https://davidraab.github.io/posts/variable-arguments-in-fsharp/ One question that appears in F# from time to time is: How do you create a function that expects a variable amount of arguments? A short answer is: You can’t do that. A longer and correct answer: You can do it with (static) methods. But you probably don’t want to use this and look for an alternative. First we should look at the difference between an F# function and a (static) method. https://davidraab.github.io/posts/mutabaility-vs-immutability-validation/ Mon, 27 Feb 2017 00:00:00 +0000 https://davidraab.github.io/posts/mutabaility-vs-immutability-validation/ I already wrote an article that explains immutability, but one thing I hand-waved was the benefits of immutability and why you should program with immutable values. In this article I talk about those benefits by trying to maintaining valid objects at all time and show how we can achieve it with mutability and immutability. One question might be why I’m not just showing the immutable part. I could do this, but the problem I see is that it isn’t so obvious how hard the mutable part really is. https://davidraab.github.io/posts/function-application-and-composition/ Sun, 25 Sep 2016 00:00:00 +0000 https://davidraab.github.io/posts/function-application-and-composition/ Function application is probably one of those terms in functional programming that sounds more scarier as the topic really is. The idea behind functional application just means that we execute a function to get the result. Let’s take the example of calculating the square root of 2.0. We can write the following in F# to do that: 1 let x = sqrt 2.0 The interesting part is how we read this example. https://davidraab.github.io/posts/catamorphisms/ Sat, 28 May 2016 00:00:00 +0000 https://davidraab.github.io/posts/catamorphisms/ Up to this point I created various articles about fold, in my Series I also created a category named Fold (Catamorphisms) but up till now I didn’t explained how this articles related to each other, or what Catamorphisms mean. In this article I want to talk about the remaining parts. The List Catamorphisms is a generalization that emerged from the list data-structure. The list data-structure, how it is found in functional programming, is usually build as a single linked list. https://davidraab.github.io/posts/monoids/ Tue, 24 May 2016 00:00:00 +0000 https://davidraab.github.io/posts/monoids/ A monoid is a simple concept. It is a generalization of some patterns that you very likely already have seen. Being aware of those can help in designing some operations and can simplify things. Without much further ado let us look at three simple math equations. 1 + 2 = 3 (1 + 2) + 3 = 1 + (2 + 3) 1 + 0 = 0 + 1 Binary Operations When we look at the first equation we just see the following: There exists some kind of binary operation that takes two things of the same type, and somehow combines those two things into one result of the same type. https://davidraab.github.io/posts/introduction-to-functional-programming/ Wed, 11 May 2016 00:00:00 +0000 https://davidraab.github.io/posts/introduction-to-functional-programming/ In this article I want to give a general introduction to some of the fundamental ideas of functional programming. I just start with the idea of function as data, and explain why functions are viewed as data and why it makes sense to pass functions as arguments. When we understand this concept, I start explaining lambda expression, currying, partial application and closures. All of this ideas built on each other. https://davidraab.github.io/posts/option-module/ Wed, 11 May 2016 00:00:00 +0000 https://davidraab.github.io/posts/option-module/ The Option type is a well known and often used type, but at least for me, most of the time I just used Option.map and Option.bind and ignored functions like Option.exists, Option.filter, Option.fold and so on. I spent some time with those functions to understand when those are useful. defaultArg The first function i look at is actually not in the Option module. It is the defaultArg function. With defaultArg we can extract an option type and provide a default value in the case we had no value. https://davidraab.github.io/posts/cps-fold/ Sat, 07 May 2016 00:00:00 +0000 https://davidraab.github.io/posts/cps-fold/ The most general function to traverse a data-structures is the fold function. But fold has one problem that is sometimes not optimal. It always traverses the whole data-structure and we cannot abort the recusion early. But sometimes, that is exactly what we want to do. For example when we want to search for a specific element in a list, when we found it, we don’t want to go through the remaing list. https://davidraab.github.io/posts/algebraic-data-types/ Tue, 26 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/algebraic-data-types/ When we work in a programming language we usually have some primitive data-types likes int, float, string, bool and so on. All of those are important, but when we need to create more advanced logic we usually want to create our own data-types and group/compose different types together to create new data-types. In an algebraic type-system there exists two different ways in how we can compose types. They are named Product-types and Sum-type. https://davidraab.github.io/posts/continuations-and-foldback/ Sat, 16 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/continuations-and-foldback/ In From mutable loops to immutable folds we implemented foldBack through rev and fold. In this post I show you how you can implement foldBack by using a continuation function. Functions Before we see how to implement foldBack, I want to give you analogy first. This analogy helped me in a lot of cases. I hope that this analogy will also help you in better understanding the further post, or probably even in other areas in programming in general. https://davidraab.github.io/posts/sequence-and-traverse/ Thu, 14 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/sequence-and-traverse/ One problem that appears from time to time is that we we have some kind of collection (I use list here) and we want to map every element with a monadic function 'a -> M<'b>. This then returns a list<M<'a>>. But often we want a M<list<'a>>. To be more concrete. Let’s assume we want to turn a list of strings into integers. We could write a tryParseInt function that does string -> option<int>. https://davidraab.github.io/posts/applicative-list/ Wed, 13 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/applicative-list/ In Applicative Functors I primarily used the Option type to show how you implement and use an Applicative Functor. But the concept also works for any other type. This time I want to show you the idea of an Applicative with a list, what it means, what you can do with it and how apply works. Implementing apply Currently the List module don’t offer a apply function. So we must write it on our own. https://davidraab.github.io/posts/optionals-app/ Mon, 11 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/optionals-app/ In this post I want to talk about Optionals more deeply. I already wrote about null, but I noticed that it is still not immediately clear on why Optionals are better. Instead of focusing why null is bad, this time I want to focus why Optionals are good. For this purpose I also wrote a small application that I will cover. But first, let’s go over Optionals and see which benefits they have. https://davidraab.github.io/posts/loops-to-folds/ Tue, 05 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/loops-to-folds/ When we ask of key-features of functional programming, you will probably hear two things most often. Immutability and recursion. But why is that so? As Immutability also becomes more important in OO languages you will probably find a lot of reason for that one, but why are recursive functions so important? The short answer is, because of Immutability! To understand the connection between those, let’s start with some code that uses loops with mutation. https://davidraab.github.io/posts/understanding-bind/ Sun, 03 Apr 2016 00:00:00 +0000 https://davidraab.github.io/posts/understanding-bind/ In Understanding map we learned that implementing a map function is what we call a Functor. In Applicative Functors we extended that idea with the return and apply function and we call the result an Applicative Functor. The next important function in our toolset is the bind function. Monads The combination of return and bind is what we call a Monad. But currently I will not consider this as an introduction to Monads at all. https://davidraab.github.io/posts/applicative-functors/ Thu, 31 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/applicative-functors/ In my previous article Understanding map I introduced the map function and described that implementing map and fulfilling two laws we get what we call a Functor. In this Post we discuss the apply function that we can view as an extension to the map function. Problem with map It might be that you have noticed one problem with map. map only can work with one-argument functions! The definition of map expects a function 'a -> 'b as it’s first argument. https://davidraab.github.io/posts/understanding-map/ Sun, 27 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/understanding-map/ One important function in functional programming is the map function. When I learned F# I must admit that I had some problems first, understanding it. The problem was, I already knew the map function from dozens of other languages. Or to say it correctly, I mostly learned a wrong explanation of map. The typical explanation I’m talking about often goes something like this: map takes a function and a list. It applies the function to every element in the list, and returns a new list. https://davidraab.github.io/posts/exceptions-are-evil/ Fri, 25 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/exceptions-are-evil/ Most people today agree that null is evil, and they try to get rid of them. One technique that most people prefer is to throw an exception in the case of an error, or if we cannot return a valid value from a function. The problem is, exceptions are not any kind better than null, and they don’t solve any problem that null introduced. In my previous post null is Evil i mentioned seven problems that null introduced. https://davidraab.github.io/posts/higher-kinded-polymorphism/ Thu, 24 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/higher-kinded-polymorphism/ One aspect of a programming language that is often noted as important is the idea of Polymorphism. But there doesn’t exists just one type of polymorphism. In functional languages Parametric Polymorphism (aka Generics) is often used. Haskell was the first language that introduced “Higher-kinded polymorphism”. Sadly, F# don’t support this kind of polymorphism directly. Actually it only has partial support for it. So let’s look in what it is, and why you want it. https://davidraab.github.io/posts/null-is-evil/ Sun, 20 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/null-is-evil/ Tony Hoare once said: I call it my billion-dollar mistake. It was the invention of the null reference in 1965. So, why did he added “null” in the first place? Why was it such a big mistake. And if it is such a big mistake, what are the alternatives? The purpose of null To understand why it was a mistake, let’s look why it was even added in the first place. https://davidraab.github.io/posts/immutability-and-functions/ Mon, 14 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/immutability-and-functions/ One important concept in functional programming is immutability. But also in object-oriented programming immutability and so called immutable objects getting more attention. The problem that I see especially from object-oriented programmers are really bad explanations. A lot of explanation I had see described it like this: Just create a class and make all fields readonly (final or const) and you have an immutable object. Explanations like these are horrible. Such explanations are so simplified that I would even call them wrong. https://davidraab.github.io/posts/introduction-fsharp/ Thu, 10 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/introduction-fsharp/ When I remember the first time I looked at functional(-first) languages like F#, ML, Haskell and others. The typical reaction that I had, and I always see from other people is: This is unreadable, it must be hard to read, it feels complicated and hard. After spending some time in F# I cannot agree to that at all anymore. Often the syntax itself is easier (for example compared to C#), shorter and in my opinion more readable. https://davidraab.github.io/posts/applying-structured-programming/ Wed, 09 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/applying-structured-programming/ In my previous post about Structured Programming I talked about that basic looping constructs fold. But this is still to powerful. In the sense of readability we should try to eliminate them with more specific ones. In this post I go through a toy example to show the various ways on how to refactor some code. The Toy Example Recently I had some conversation about code in a game and providing some kind of critical hit-chance in a game. https://davidraab.github.io/posts/structured-programming/ Wed, 09 Mar 2016 00:00:00 +0000 https://davidraab.github.io/posts/structured-programming/ Back in 1968 Edsger W. Dijkstra wrote an open letter named “Go To Statement Considered Harmful”. As already suggested from the title, the very idea was to raise consciousness that the goto statement is more harmful then helpful. From today view we would expect that this idea catches fire really fast, but it didn’t. It took quite a long time. Even during all the 1970s and 1980s that question was debated a lot.