Got Koss KPH40 utility recently and it's pretty fun. It's not as loud as I'd like but the sound quality is quite good. Pretty good detail with suprisingly decent bass. A tiny bit of sound-leak but not that bad. Sits quite comfortably on the head.

Whatever. We all know this already. That's already talked about but 1 criteria nobody mentions is headbangability. I was an IEM person for the most part because I move my head a lot when music plays. KPH40 stays on my head fine but for a violent enough head shake, it starts moving. It survives mild desk headbanging pretty well but, not as good as an IEM.

6/10 headbangable. Up next, my review on condom helicopterability.

It's not breaking news that a lot of subscription services are predatory towards their customers. But spotify taskes it a step further and is predatory towards their artists as well. And thats just for the popular artists, newer artists and niche ones cannot survive with this.

Why am I avoiding piracy if the artists still barely get paid? Answer my question, Lars!

In exchange they offer convinience to both sides. Is that really worth it? I thought so for a while too but then I started feeling uncomfortable with the whole thing.

So what are the alternatives? Theres a lot of good options but the technicality and time spent evaluating the options might put off some people.

• Self-hosted music streaming server: jellyfin server, mopidy, navidrome, LMS
• Music client: Symfonium, mopidy-iris (for mopidy), jellyfin client Finamp (for jellyfin)
• Self-hosted music discovery: explo + listenbrainz
• Purchasing music: bandcamp, https://www.qobuz.com

This path is way more accessible and convinient than it might seem at first.

Another much simpler alternative is to use a physical music player (or just your phone) and load all your music files in there. I use a snowsky echo mini which has an sd card with all the albums I own (flacs from bandcamp) which is a fair compromise for me.

Spotify can suck it.

A band like Mr. Bungle is rare because given how hard it is to make enough money to survive as a band, I'm surprised how more bands don't lean towards mass appeal. But Mr. Bungle is comfortable with just finding an identity in making the songs that they want to make, even if that identity involves including the track 'Noises' in your album.

For people who want to get into them, the album order I enjoy is California -> Mr. Bungle -> Disco Volante -> everything after that. To me that is ordered by weirdness because I like starting comfortable.

Reddit decided to kill their RSS feed. They say AI and scraping but that translates to "only we should make money off selling user content here". That was also the reason why they priced their public API to death previously and now that's killed for real as well. I think the internet as a whole is turning hostile towards people that want to consume content on their own terms. This is because of the sudden inflation of the value of user data caused by AI's presence. Before it used to just be about selling user data for targetted ads, now it's all about AI, baybee. So I wouldn't be surprised if more public RSS feeds and APIs start disappearing and eventually the only way to interact with the internet would be via AI and summaries of inaccessible information. A few big AI companies become the only medium for the internet and privacy becomes the thing we get all nostalgic thinking about. We're kinda fucked.

Given the shitshow every single medium of accessing information and entertainment feeds has turned into with organizations optimizing the amount of time people spend on their apps, I think we need more neutral sources. Source that are not trying to "understand" us to manipulate us into using their app more like the most toxic relationship. RSS seems like the only good standard left for this. I really like that youtube and reddit have official rss feeds which I use a lot. And I'm also very happy with the amount of blogs I've found that provide an rss feed. But we could definitely use more of this. We also need to normalize it's use to the point where people lean towards rss instinctively rather than reaching for the apps/websites.

Kakoune doesn't have built-in support for snippets. You can use plugins like occivink/kakoune-snippets to have that in the editor but you could also have a much simpler setup for snippets with a few lines of scripting.

My first iteration of snippets was just to use commands and prompt for input like so:

declare-option -hidden str-list snippets_list

define-command snippets-insert %{
  prompt -menu 'Snippets: ' \
    -shell-script-candidates 'echo "$kak_opt_snippet_list"' \
    %{ evaluate-commands %val{text} }
}
define-command define-snippet -params 2 %{
  set-option -add %arg{1} snippets_list %sh{ echo -e "$2\n" }
}

hook global BufSetOption filetype=(?:ruby) %{
  define-snippet buffer snip-rails-class
}

define-command snip-rails-class %{
  eval %sh{
    class_name=$(basename "$kak_bufname" .rb | sed -e 's/[^A-Za-z0-9]\(\w\)/\U\1/g' -e 's/^\w/\U\0/g')
    echo "set-register c $class_name"
  }
  execute-keys '<esc>,i# frozen_string_literal: true<ret><ret>'
  execute-keys 'class <c-r>c<ret>'
  execute-keys 'end'
}

Here, it parses the ruby class name from the file name to generate the snippet but this could also just be a prompt command instead.

This worked okay but it was pretty hard to maintain. Would be much easier if the snippets themselves were easier to create and read. So, that eventually evolved into this:

declare-option str snippets_dir "%val{config}/snippets"

define-command snippets-insert -docstring 'Snippets' %{
  prompt -menu "Snippets: " -init "%opt{filetype}/" \
    -shell-script-candidates %{ fd --type file --base-directory "$kak_opt_snippets_dir" } \
     %{
      evaluate-commands %sh{
        case "$kak_text" in
          *.snip.kak) cat "$kak_opt_snippets_dir/$kak_text" ;;
          *) echo "insert-text-snippet %{$kak_text}" ;;
        esac
      }
    }
}

define-command -hidden insert-text-snippet -params 1 %{
  execute-keys ",|cat ""%opt{snippets_dir}/%arg{1}""<ret>"
  execute-keys -save-regs '' "s[$]\d+<ret>"
  execute-keys "%sh{echo $((kak_selection_count + 1))}n"
}

Now each snippet is a file placed in ~/.config/kak/snippets/. The files in my case are organized by filetype in directories as {filetype}/snippetname.{ext} or {filetype}/snippetname.snip.kak. The prompt is filled with {filetype}/ so at first you see the snippets for the current filetype but you can delete that in the prompt to see all.

If it's a .snip.kak file, it is evaluated as a kakoune script which is the same as the commands from before. Otherwise the contents of the snippet file is inserted into the buffer directly and any $n ($1, $2, ...) will be added as a selection. Example:

# frozen_string_literal: true

class $1
  def initialize
    $2
  end

  $3
end

The above snippet, $1 is automatically selected first. You can press c to change it and Esc to go back to normal mode. Then when you press n, it jumps to the next $n.

I know this already exists for every other editor out of the box and is much more fleshed out but the experience of understanding a system and defining a feature within it, in it's simplest form, is a really pleasant.

Using nixos is a chore like brushing your teeth. Oh... I mean "teeth being brushed" (declarative).

It takes work. A big investment up front in configuring it and tiny investments for as long as you use it to maintain the configuration. Sounds like a scam but I thank myself for this investment every time there is a bad update or running a project with a flake and having it work fine after many years of sitting idle (which is suprising in the modern norm of having a web of dependencies). This brings an insane amount of confidence in any change I make to my system which lets me explore more things without being afraid touching the wrong thing on MY computer.

I've had it running as a daily driver for about 6 years and on my home server (just an old laptop) for more than a year. My review: 10/10, do it.

I've tried a bunch of different code editors and IDEs over the years but nothing beats the control of a modal text editor. Even as "vi plugins" in normie editors and IDEs, the difference in user experience is massive. But I've come to crave more from my tools. By "more" I mean fewer features and better primitives to allow me to build my own experience on top of it. Because at the end of the day, I've spend a considerable amount of time using the tools that I use for work and as a hobby so I know better than the devs of these tools what I'd like my tool to do.

For a while my answer to this was neovim (vim before that). Neovim is a really solid code editor and it comes with the simplest and a really powerful configuration framework for building on top of it (emacs guys suck it (jk, I love emacs too)). I dove so deep into the lua rabit-hole that I trimmed my setup down to a few essential plugins and every other feature was implemented by me in my config. But over time, I've felt like the foundations are a bit "off". The primitives that it provides felt a bit inconsistent and like carrying too much weight for my taste.

So as any mentally ill person would, I decided to spend a shit-load of time setting up a kakoune configuration that I could use many moons ago. And it just made sense. Kakoune's shell based extension framework is exactly the kind of simplicity that I was looking for. It is in no way a perfect editor but it fits in my hands perfectly. No file explorer, no build system, no fancy built-in language server, no split windows, etc. Nothing other than a simple code editor with a good-enough configuration language that lets you integrate kakoune with any other tool you want. I have unix blood in my veins. This kind of workflow turns my terminal into an IDE with the editor just being a part of it (instead of the other way around. Looking at you, emacs). I still love neovim and might go back to it in the future but kakoune feels right for now.

My crotch has never been wetter. Kthanxby.

Love DRC. Can't live without it. Want more. But there's some things that DRC doesn't know how to do out of the box like verifying the skew in my differential pair traces or telling me I'm a good boy. Luckily custom rules makes up for it (at least the first part)!

Go to Board Setup > Design Rules > Custom Rules (or manually edit *.kicad_dru file, if you're not right in the head) and add the following:

(version 1)

(rule "100Ohm differential pair skew"
    (condition "A.NetClass == '100Ohm'")
    (constraint skew (max 0.05mm) (within_diff_pairs)))

The above rule is specifically for a net class named 100Ohm. This will show up as an error if your differential pairs have a skew greater than 0.05mm. You can also use A.hasNetclass('DiffPair-*') if you have some DiffPair-100Ohm, DiffPair-90Ohm, etc. convention going on. Or combine them as (condition "A.hasNetclass('100Ohm') || A.hasNetclass('90Ohm')")

There's a bunch of other constraints you can check for like diff_pair_uncoupled, diff_pair_gap, track_width, etc. Check the "Syntax Help" thing in the modal to see more stuff it comes with.

I recently tried decided to randomly pick up a pcb design project for an stm32 based toy music instrument that used capacitive touch sensor traces on a PCB. Expected it to be a bit of a challenge because I've never dealt with most of the components involved and only have basic experience with SMD components.

Stuff I've learned:

• keep in mind ICs with identical i2c addresses when you have multiple devices on an i2c bus. Use separate busses if possible or i2c multiplexer if thats becoming a problem
• dont forget the cc pins on a usbc connector
• read the datasheet more carefully and dont just rely on the "typical application" diagram
• keep pcb traces in mind when drawing schematics. Not to have them laid out the same way, but whenever there's a choice for which pins keep the ICs position in mind. Or just re-do the connections in the schematics later, I'm not your dad
• add extra header pins/test pads to make debugging easier. Always design for testing.
• use solder jumpers and DNP resistors as "flags" if needed
• add the mounting holes as soon as possible after board outline to reserve enough space for them
• for mcus, plan the firmware early on when drawing out the schematics
• pay attention to res pullups values for i2c lines based on the frequency (from i2c spec). Used 4.7K on mine which seems alright
• dont move the ic around in the pcb and leave the bypass capacitors behind (happened twice)

project is wip so will add more here as a fuck more things up...

I think people who make SBCs should add at least 2 UART ports. RPI zero just has 1 which hurts when you want to reserve the UART port for serial console and then all of a sudden you also need it to communicate with some other module. I'm in that situation right now.

Options I have:

1. USB for console with dwc2 (depends on SBC). UART for module.
2. UART for serial console. USB-to-serial adapter for module (or vice-versa but makes more sense if console's serial device can't be unplugged).
3. UART for serial console. Bit-bang the module at a much lower baud rate (if that's supported).
4. Board has wifi? Just ssh into it. Although, seems overkill for simpler use-cases and might not be ideal in some situations. Not an option for my pi zero.

Maybe theres another option that I'm not aware of?

Going with 1 because it's less work on a pi zero. USB-to-serial if the board doesn't support dwc2. But for a serial console you have to 69 2 USB-to-serial adapters to get a console. But all of this goes away if you just fucking add the 2nd UART port.

I want to mess around with FPGAs at some point. It looks really interesting but I need to grow a few more IQ points before I can play with that new toy. At this point I know nothing about them or hardware description languages but can't wait to meet future me who already knows some of that stuff. If that's you reading this for some reason, is GTA 6 out yet?

I only ran into v-usb while going through the qmk docs where it mentions that mcus that don't have native usb will use v-usb instead.

Curiosity killed the akshay. Couldn't resist so started thinking of what I could use it for. Right now I'm in my 8-bit avr arc so seemed like the perfect thing to mess around with. I thought it would be fun to make a simple rgb light connected via USB that changes color via commands over serial. Seems simple enough, what could go wrong? Plenty as it turns out.

First challenge: realized the internal clock of attiny84a and attiny4313 (the only 8-bit avr mcus I have) is 8MHz and v-usb only supports 12/15/16/18/20 MHz clocks. No biggie, heres a 16MHz crystal oscillator.

Second challenge: we need 3.3V for the usb data lines but the LEDs need 5V. I can either drive the attiny4313 with 3.3V and maybe add a mosfet for the LEDs or use 5V for the mcu and LED but shift D+/D- to 3.3V level. Went with the latter using a zener diode to maintain the 3.3V level on data lines since that seemed simpler.

Third challenge: after writing the fuse bits to use the external crystal oscillator, couldn't program it again. The crystal is connected with load caps and the program (an rgb version of blink) seems to run fine with or without the crystal. Makes no sense. Saw somewhere that you can set up a high voltage programmer (12v) to get the fuse bits to reset. So will try that next.

To be continued...

In digital electronics something that always catches me off guard is the analog suprise. Don't get me started on signal integrity issues but what I'm talking about is when a random part of your schematic depends on a very specific analog behavior. I ran into one of those while working on a clock using attiny84a microcontroller IC. That project was my re-creation of breadboard watch which taught me a very simple but neat trick.

An rtc based on timer interrupts on a microcontroller, displayed on a 4 digit, 7 segment display seems simple enough but theres a sneaky problem with attiny84a. The total number of pins in the IC is 14. 1 for Vcc, 1 for GND, 1 for reset. Since it's battery powered, to avoid drawing more power than needed, we also need to use an external 32KHz crystal oscillator which then takes up the 2 XTAL pins. This leaves us with 9 pins to drive the display. But for 4 7-segment displays, you need 1 shared pin for each segments and 1 control pin for each digit. That comes out to 11 (7 + 4). But we only have 9 pins left so how do we drive the display?

In avr, for a given pin, you can set the data direction (DDR* register) and the port value (PORT* register). When DDR bit is 1, the data direction is output so the respective PORT bit decides whether the output is high or low. But then if the DDR bit is 0, the value of PORT instead of being used for the output of that pin, it engages an internal pull-up resistor if the value is 1, and leaves it floating if the value is 0.

This is the magic that makes feel things in the crotch. The solution used here is to use diodes to create a sort-of OR circuit by deriving segment states based on the state of the control pins. Here's the full schematic for reference.

Note: in my case it's a common anode display so segment pin low and control pin high means that segment on that digit is on.

In the schematic, with DDRA = (1 << PA6) | (1 << PA7) (PA6 and PA7 both output),

• When PA6 is high, and PA7 is low, it enables digit 3 and the F segment.
• When PA6 is low, and PA7 is high, it enables digit 4 and the F segment.

If we have DDRA = 0 (PA6,PA7 both input),

• When PORTA = 0 (PA6,PA7 without internal pullup resistor), being floating, there is no current flowing which means both digits are off and the F segment is off. This state can be used when drawing the other 2 digits.

So far we can turn off both digits or have either one on but with F segment enabled. But how do we disable the F segment?

If we have DDRA = (1 << PA6) (PA6 output, PA7 input),

• When PORTA = (1 << PA6) (PA6 high, PA7 floating), digit 3 is on but the F segment is off as the current has nowhere to go through the diodes.

Applying the inverse of that, we can achieve the last state we need to draw anything on each of the 7 segment displays. With this we now have 2 pins doing the work for 3. Adding in-between states in our digital logic that don't exist in pure boolean logic. Doesn't that feel satisfying?

code

I see a butterfly... turning into another butterfly... turning into another butterfly... turning into... eh I'm bored.

code

code

I like ice cream sandwich. A lot more when I stop liking everything else.

code

I don't like eyeballs

code

Order from chaos

code

Koduval is a tool used for cutting open coconuts (among other things) in south India.

Flames

Glide

Now and then

Stuck in beetween

Doorway

Fibers

code

All about the flo, bro

code

Placenta is an organ that develops in the uterus during pregnancy to connect the mother and the developing fetus.

code

4K version

Fun fact: moths fly towards light because night-night really scary

code

code

code

code

He's not wearing anything under that

code

code
older uiua version

code

code

code

code

For a while programming was one of the most lucrative career options for someone to pick. Still is to some extent. But there was a time before all of this when computers weren't everywhere as they are now and majority of programmers were just nerds with a niche hobby.

With the whole AI takeover of the industry, the value of code has gone all the way down. A lot of people have lost interest in writing code by themselves. The value of code is as low as it was back then and writing code is not really a job anymore. We've come full circle.

This at first made me feel sad about the state of things. Mainly because of the huge discrepency between how I feel about coding and how the world does now. But that feeling was short-lived because as it turns out, I still feel the same way about code as I did when I first started. It's still as satisfying and enjoyable as the first "hello world". Yeah most of the software industry now uses AI to produce code, but thats alright. I can still write my own code in my free time and I still love doing it!

There's so much depth to programming, so many rabit holes to dive into and so much more to learn that coding as a hobby will stay fun for me for the foreseeable future. I won't be using AI for any of the code I write for fun because I don't care about producing hobby code faster. I wouldn't use an ice-cream eating robot to eat my ice-cream for me just because it can do it faster or better.

So yeah, coding's just a niche hobby again. And it's a really fun one!

Just go over to desmos and type a random equation with polar coordinates. There is a very good chance, you see something visually interesting.

Examples (try with −12π ≤ θ ≤ 12π):

• r = θ: the simplest form is already a spiral
• r = θ²: sqaure it, something that looks like infinite hear shapes
• r = e^θ: try zooming into it, it goes on forever
• r = sin (0.3θ): some floral shape. mess around with the factor (0.3) to watch it unravel in really cool ways.
• r = e^{θ(sin (θ)cos (θ))6}: would make a really cool visualizer for music

Designing a logo? Just play around with polar coordinates till you find a shape inside it that looks interesting. Won't take long.

Been trying out creative coding in sqlite recently here. Turned out to be a lot more fun than what writing practical SQL had conditioned me to believe!

Generating images is pretty straight forward. The SQL uses recursive CTE to generate and store pixel rgb values in the db. Then a bash script reads the pixel values structures them in the ppm text format which is then converted to png using imagemagick. I was thinking of taking this a step further by converting to ppm from within sql but didn't feel like that added much except boilerplate.

Currently I've got 2 scripts image.sh and video.sh to generate images and videos respectively.

• image.sh: Generates a ppm from the pixels stored in the db. Uses imagemagick to convert that to a png (and also for displaying it)
• video.sh: Generates a ppm stream for each stored frame of the video. Uses ffmpeg to convert that to a gif (and uses ffplay for displaying it)

Here's a simplified example that generates 400x400 grid of pixels with a circle in the middle:

WITH RECURSIVE
    image(width, height, cx, cy, radius) AS
        (SELECT 400 AS width, 400 AS height, 200 AS cx, 200 AS cy, 160 AS radius),
    horizontal(x) AS
        (SELECT width FROM image
            UNION ALL
            SELECT x - 1 FROM horizontal WHERE x > 1),
    vertical(y) AS
        (SELECT height FROM image
            UNION ALL
            SELECT y - 1 FROM vertical WHERE y > 1)
SELECT x, y,
    255 * MAX(0, MIN(1, (x - cx)*(x - cx) + (y - cy)*(y - cy) - radius*radius)),
    150,
    150
    FROM vertical, horizontal, image;

Here, horizontal/vertical generates x and y coordinates, the final select assigns the r,g,b values for each x,y coordinate which is what allows generating the visuals.

In the repo, I'm storing the pixels instead of generating just generating them directly. I went with this approach for 2 reasons - debugging and reducing the pain of generating a video. Although, could've used materialized views but nah simpler is better.

Generating audio out of samples should also be simple with raw PCM data and then to ffmpeg to convert to wav but haven't tried that yet. Another more ambitious idea is to build a simple snake game. The way I'm thinking is with the ppm output streaming to ffplay and using terminal raw mode for input which will update relevant values either directly or via triggers. Leaving that for future me to fuck around with.

SQL can be fun.

Desmos is a graphing calculator where you can input math equations and it'll plot it. The normal way to use it would be to throw in an equation like y = 2x² + 2 and boom you have a parabola. Even though it might seem simple on the surface, it is hiding an incredible programming language and rendering engine that you can use to build pretty much anything you'd like.

Want to draw a box and a circle? {−5 < x < 5}{−5 < y < 5} > 0 x² + y² < 25

Here, the comparisons at the top level means region (or range in general) and conditional enclosed in curly braves like {−5 < x < 5 > 0} are expressions that can either return 1 if true or undefined if false. 2 of these expressions next to each other is the product of both.

Want to conditionally draw either a box or a circle and toggle between them on the click of a button? (on desmos) {V_iscircle = 1 : −x² − y² + 25, {−5 < x < 5 > 0}{−5 < y < 5}} > 0 V_iscircle = 0 V_iscircle → {V_iscircle = 0 : 1, 0}

Here, if you click the arrow button to the left of the last equation, it will update/toggle V_iscircle. An expression like {x > 0 : 42, 7} is a conditional expression but instead of 1 or undefined, it will return 42 when true and 7 when false (i.e. if expression). Also, V_iscircle → {V_iscircle = 0 : 1, 0} means when the action is triggered (button is clicked or via timer), it will update the value which in this case would toggle between 0 and 1.

The action can also be connected to any object drawn on screen by clicking the cog in the sidebar, clicking on the icon to the left of the equation for the object and then enabling "Clickable".

You could also have that action be triggered every second (or whatever interval) using the ticker feature in desmos (+ button in the sidebar > Ticker).

This post doesn't even begin to cover the incredible features desmos provides but I think the fun is in exploring so if you find desmos interesting, it's better to discover those yourself.

Here's a snake game implemented in desmos. Press "Play/Pause" to start.

I maintain my collection of desmos experiments here.

Uiua is one of the most fun languages for creative coding. There are a bunch of really good primitives for generating audio files from samples, generating an image from an array of pixels, generating a gif from an array of array of pixels, etc. Messed around with it here some time ago and I've started to miss it. The only other APL-ish language I've tried is BQN which is also an amazing language but thinking tacit is hard and it takes time to get used to. There are smart people in the world. Being a member and representative of the other side of that spectrum, I need my escape hatches and they need to be pleasant. I've come to appreciate the stack-based escape hatches a lot more than the functional escape hatches with blocks using 𝕩 and the other spicy letters.

Something about spiders have always been interesting to me. I've spent so many hours on wikipedia reading about spiders, that the spiders have a restraining order against me.

Jumping spiders especially are wonderful. Incredibly cute little guys. Have you ever stared at a jumping spider and they turn and lift their heads to look at you? Fucking adorable. And don't get me started on their "uppies" front leg lift when they're hopping up on your hands. I've got a few jumping spiders around the house. Not pets, they just live here.

They are incredibly smart, excellent hunters. They have object permanence which is suprising for a brain that tiny. They have conical eyes (hence the head lift to look at you), that they can use to focus on fine details over long distances. Nature couldn't have come up with a better design. It is really a treat to watch them wander around and hunt.

The bigger ones although are intimidating. A few years ago I was visited by a huntsman. He just entered my house like he owned the place and for a second I considered moving. I knew he couldn't hurt me. He wouldn't really want to bite me and even if he did, it would just be a little swelling. But my instinct wouldn't let me get close. I ended up using a shakey bowl (my hands weren't shaking, it was just a shakey bowl) and a piece of cardboard to relocate him outside my window. But after we had my window between us, I found the guy really beautiful and impressive.

Another spider encounter was with a wood orb weaver spider when I was visiting Kerala, India. I accidentally touched a bit of web between branches that felt surprisingly strong, almost like a bit of thread. I looked up and there was this magestic web between 2 trees with a giant yellow, black patterned spider with a red dot on it's butt. That butt comment felt innapropriate the moment I realized that it was a lady I was looking at and the male of the spicies was the much smaller spider on the web that I didn't even notice at first. Again scary as hell but I couldn't stop looking. The patterns and her leg movements were mesmerizing.

Jumping spider	Huntsman	Wood orb weaver

Anyways, spiders are scary but pretty damn amazing.

Ever since the Reign of Terror, I've been craving some good old fashioned dramatic public executions. Hell yeah, bring that back! Especially now that I don't have to walk all the way to the guillotine and can just watch it online from the comfort and safety of my own home, with my dick in my hand. Honestly kind of sick of watching things online where no one dies. I need to feel something, damn it!

If you're one of those people with empathy, stop pretending. You obviously only care about the people on your side. If you're one of those people who really have empathy, relax a bit. The light hitting the lens of the camera, travelling through the interent as bits, and eventually turning into pixels drawn on your screen washes away all meaning so at the end of the day, it's just a livestream, bro. Like watching a scene from a movie where the bad guy dies. You don't have to feel bad. If you still feel that way, try watching it 10 more times, that'll fix your disability for sure. Or if you wait a few minutes, you'll probably see a bunch of memes about it which is the best way to stay up-to-date on current events since you can laugh about it and the "too soon" laws don't apply. Humanity is evolving, get with the times or go extinct, preferrably in front of a camera so I can watch.

If history repeats itself, it would be really fun to watch all the kings' turn on the guillotine. Isn't this just a wonderful era we're a part of?

Nightmares are so much fun! It's the most immersive horror movie you've ever watched. Or a comedy-horror movie about how you're in school again standing naked in front of all your classmates because you forgot to wear your clothes and you realize that this is more than just about your clothes. You exist in a perpetual state of shame with no end in sight. You talk about acceptance but then use every chance you get to criticize yourself for... Okay, I take it back, nightmares can be bad I guess.

I am the last person who would complain about bugs in tools I use. Being a dev responsible for many bugs over the years, makes me empathize with other devs so even the most frustrating buggy experiences I run into ends with me going "eh, shit happens".

But recently, the web has been a bit more buggy that I'm used to. Websites and apps just breaking all over the place. From the people I've spoken to about this, I no longer think it's just me. The theory that came up is all the AI-driven work done in the software industry but I don't think that's it. As much as I dislike AI's forced involvement in everything, I don't think the problem is just AI, but rather the effect this is having on people. I think the disorientation from being pushed in the deep end with AI is making experienced devs careless and hurting our attention to detail.

Attention to detail is what I appreaciate about the output people produce in the world. So people losing that makes us a lot less interesting and apps a lot more useless. Hope that turns around.

Let's just stop creating. What has being creative actually got us, really? Let's just consume. Time to replace every outlet that humans have to produce any kind of output and turn that into an act of consumption as well. We've already succeeded in doing that to all forms of digital works - art, code, writing, videos, etc. but why stop there? I took a shit earlier today, why even that? Let's pass a law that some corporation owns all shit in the world and people are legally obligated to buy it from them for permission to drop it out of their assholes. Otherwise the corporation is well within their right to sue them for damage to their property. Add a toilet-seat + flush monthly subscription to that and boom, utopia!

And the water after I wash my feet but at least that has the decency to dry itself after a bit.

Can you say that you truly understand the tools you use?

Text editors like vscode (or any other web browser as a text editor things) or an IDE like intellij, are a russian doll for layers of abstractions that you're meant to accept as a whole and never think about. With something like vscode, there's the editor itself, all the integrations that it comes with, the browser behind the scenes that renders everything, some electron magic that connects that browser internals to your system, whatever nodejs does, etc.

But as a programmer, that feeling is something that I've grown very uncomfortable with. Which is partly why I've always gravitated towards tools that are simple and let me break that abstraction and build around it. The cost of that choice is of course that you have to trade off some convinience to do this either as a one time investment to set it up or a continuous cost if it's not very easy to use.

Prompt-driven programming before AI

Back in the day when people thought we'd have flying cars by the year 2025, the primary way to interact with a computer was through a teletype interface. Not a fancy terminal emulator that allows displaying images or one that asks you to sign-up with your email address to use your terminal, just a regular ol' teletype terminal.

So an obvious choice to write code within this environment was an editor that took commands for editing text and applied those commands on the file. One such solution was a line-wise text editor called ed.

The way you edit text in ed is using commands in a repl interface that operate on lines. You can delete/insert/append/change/move/copy lines. If you want to change something inside a line you can use the substitute command s/pattern/replacement/. There is also the global command which applies one of the other commands over all lines that match the given pattern. People familiar with vim will already be familiar with a lot of these commands.

Influence

Not going into details of the history because if you can read this, you can read wikipedia. But I can give you a lazy, poorly-researched summary which is all you'll remember from wikipedia anyway.

• At first, there was qed which inspired ed
• Then some dude said "want more" and went ahead and made ex
• Then ex got a visual mode which became vi
• Then came stevie, a fork of vi for Atari ST
• Then vi got improved when stevie got forked as vim
• Then finally we get the cool kid, neovim (fork of vim)
• Also a side-note, almost all text editors come with a vi-mode as a result of this chain of influence

But that's not all

• sed is essentially ed's line-based editing operations on streaming data (stream editor).
• grep's name comes from a specific ed global command g/re/p which prints everything that matches a given regular expression.
• theres probably more things to add here but leaving this here because I felt uncomfortable making a list of 2 items

Modern UX

Having developed a lot of different user interfaces in my career, I've come to the conclusion that modern user interfaces are designed for idiots. Not saying, those interfaces are only used by idiots but they're designed for the lowest common denominator of technologically inept.

This button called 'Move to trash' will move your file to trash. If you hover over it, it'll also show you a tooltip saying that it will move your file to trash. Clicking on it will show you a dialog box asking if you're absolutely sure that you want to move the file to trash. If you click yes and then you realize that you want the file back, you can go to the trash folder and restore it.

Just rm -rf it, you pussy.

This is done not because, it's necessary but because the people behind the tool pictured you as the worst case scenario of a user. They imagined a user so incompetent with tech that they can't be trusted with something they own. This reasoning is what then branches into a justification for the lack of ownership with a lot of modern technology but I'll leave some of this rambling to your imagination.

Simplicity

I've always found ed to be quite elegant. Not because it's a good tool to use but because of a very specific feeling associated with using tools like this. Tools that are so simple that you feel like you completely understand the underlying mechanics of it and not just as an abstraction. You don't need a hand-wavy explanation for how it works. It is obvious at first glance. There are a small set of primitives you learn (commands in case of ed) and you know everything about how to use the tool, how it works, and how to very accurately predict it's behavior. If it breaks, it must've been a bit flip because a tool that simple just can't break.

It's a breath of fresh air from all the high-level nonsense that we've been fed all our lives in the 21st century that we learn to never question and accept on faith. Not that far from religion, the way we treat all the systems around us.

Like using a hammer. You look at it and you understand it. You don't have to plug it into a wall. There's no installing updates to improve security of the hammer. There's no sending usage data to some server in the background to allow the hammer company to "improve" the tool. Ignoring the quite likely kickstarter project doing those things, it's a hammer. You hit things with it..

Most popular tools we use now are wrapped in so many layers of abstraction that we are completely disconnected from the tools we rely on. This trend is not acceptable to me.

Fun

One of the biggest case I could make to try ed is that it's just fun. It's an editor that feels very technical to use and provides enough constraints to turn the experience of editing text into a turn-based strategy game. You execute a few commands one after another, without knowing if the edits are all correct and then you print the contents inside ed and you feel the rush of getting it right! Or the disappointment of forgetting to account for the added line in a previous command.

AI

We've sort of come full circle now. Prompts to edit text is back but with the thickest layer of abstraction the world has every seen.

• You prompt it to make some edits, and it does that magically (among other things).
• You review the code (or don't if you're really vibing).
• You add it to your version control system (or don't if you're vibing extra hard).
• That's it. Do we really need a step here called "effort"?

I cannot put into words worthy of a prompt to chatgpt, how extremely unappealing this is to me.

Writing code and interacting with a computer in general has never been a means to an end for me. That is the point. I write code because I like writing code. Outsourcing that would be extremely pointless.

Inconclushun

Idk. Simple tools are fun. Bye.

Disclaimer: The following content is not very informative

Where were you on the night of 20th January? ANSWER ME, YOU FUCK! Not a talker, yeah? No problem. You'll talk eventually. They all do.

We have an overwhelming amount of evidence that suggests that you were the one responsible for turning typescript's type system into it's own purely functional programming language. What kind of a sick, twisted man, does that? You're gonna be spending a lot of time behind bars for this.

The reports suggest that you can even read/write files, perform basic io and even interop with js from it?

Take a look at some of the crime scene photos.

export type main = [
  PutStringLn<'Greetotron 6000 initializing...'>,

  PutString<'Your name? '>,
  Bind<ReadLine, <name extends string>() => PutStringLn<`Hello, ${name}`>>,

  PutString<'Your purpose in life? '>,
  Bind<ReadLine, HandleResponse>,

  PutStringLn<'Bye bye'>,
]

// Equivalent to `HandleResponse :: string -> Effect ()`
interface HandleResponse extends Kind1<string, Effect> {
  return: Do<[
    PutStringLn<`Interesting that you believe "${this['input']}" is your purpose. Hmmmm...`>,
    PutStringLn<'Judging harshly...'>,
    PutStringLn<'Saving response...'>,
    WriteFile<'./response.txt', this['input']>,
  ]>
}

Do you feel any remorse for the victims you've affected? I hope you get the chair for this.

We also found the murder weapon on the crime scene - npx tsr run ./somefile.ts. Not just that, it says here you built the weapon yourself using ts-morph as a wrapper around the typescript compiler. Did you use the source file as your runtime representation of memory, you piece of shit?! But, we're getting a bit ahead of ourselves here.

Let's get to the motive which is the only piece of the puzzle we're missing. Why would a mediocre software developer suddenly go postal and make something like this? Did someone pay you to do this? Is that what this is about? Money? Naah. This was a little more personal than that. I have a theory for why you did it. And it's as simple as it gets. You're a sick man who enjoys watching people cringe and suffer. Is that what this blog post is about? More cringe?

We've even figured out how you smuggled all the results of the io back into the program. It was a result node, wasn't it? A stray object that you injected properties into, you sick fuck. Was that your runtime representation of memory? You just used the randomly generated property name to access the result in your effects.

type __$result = {
  '90sd9...': { output: 'Result of computation' }
}

Another thing that's been bugging me is,

Why is the effects api monadic?

Was it because you wanted all operations on the results represented in the type tree so you could manipulate it?

You disgust me. In my 20 years on the force, I've never met a man as disturbed as you. Don't bother pleading insanity here though. This was calculated. No one is going to buy it.

Remember your hacky attempts at first class functions?

We have it in our custody and it's talking like a parrot. Telling us everything we need to know about your sick experiments!

interface Greet extends Kind1<string, string> {
  return: `Hello, ${this['input']}!`
}

type msg = Apply<Greet, 'EdibleMonad'> // : 'Hello, EdibleMonad!'

Yeah, we got you now, you bastard!

You weren't satisfied with this tho, were you? You wanted your first-class functions to be inline. You needed it. So you made your runtime recognize lambda functions as first-class functions.

type main = Bind<
  ReadFile<'./file.txt'>,
  <T extends string>() => PutStringLn<T>
>

But this is where you fucked up. You couldn't generalize this as a pattern because typescript doesn't work like that. Typescript doesn't support higher kinded types, dumbass! So you settled for only allowing this pattern inside Bind and Try. You flew too close to the sun, Icarus and it lead us straight to you.

You're done, buddy. This case is as good as closed so you might as well confess.

Alright! Alright! I confess!

It was me who did it. I made the runtime that turns typescript types into a purely functional programming language! I did it because I fucking wanted to! And I enjoyed every second of it!

I saw people making things that defied all logic, like an assembly interpreter within the typescript type-system. I knew if I wanted to make it do something more, I'll need a runtime! That's when I came up with my master plan.

I don't regret a thing! I've made my mark on the world even if that mark is a piss stain on the side of the street.

Akshay was charged with cringe and sentenced to death by lethal injection. It was later discovered that this wasn't all that big of a deal and completely blown out of proportion.

Ok bye

You gotta teach your effects some manners.

We work with effects everyday, but those rascals have a habit of running around loose in our programs. I'm not saying it's just bad parenting but we have to draw the line at some point.

Look at pure functions, they are so disciplined and obedient. They never get into any trouble. You ask them a question, they give you an answer. That's what you expect from good code. If you find out that your function, while giving you the answer, also went ahead and made 5 api calls, thats a good sign that your code needs some disciplining.

Let's implement a linked list

I swear this is relevant and not a plot to make you learn DSA again.

type rec myList<'a> = Nil | Cons('a, myList<'a>)

let ls = Cons(5, Cons(20, Cons(-28, Nil)))

That is a simple linked list implemented in rescript. Nil marks the end of the list and every element before it contains an item of that list and the rest of the list. They know how to stand in a straight line like good students.

But, this is an eager list since all items of the list already exist on the time of its creation. For what we're working on today, eager lists won't be enough. We need our list to be lazy. We can turn that into a lazy linked list by replacing the rest of the list with a function returning the rest of the list like so -

type rec lazyList<'a> = Nil | Cons('a, unit => lazyList<'a>)

let ls = Cons(5, () =>
  Cons(20, () =>
    Cons(512, () =>
      Nil)))

This makes it so the rest of the linked list doesn't exist till the function is called. This is helpful if you wanted to create an infinite list.

let rec fibonacci = (a, b) => Cons(b, () => fibonacci(b, a + b))

let rec take = (ls, n) => switch (n, ls) {
  | (_, Nil) | (0, _) => Nil
  | (n, Cons(value, next)) => Cons(value, () => next()->take(n - 1))
}

let rec forEach = (ls, fn) => switch ls {
  | Nil => ()
  | Cons(value, next) => {
    fn(value)
    next()->forEach(fn)
  }
}

fibonacci(0, 1)->take(20)->forEach(Js.log)

fibonacci returns a lazy list of all the numbers in Fibonacci series starting with a and b. We then use the take function to ignore the list after the first 20 items. forEach, then goes through the new list till the 20 items and logs each one out.

This is very helpful for modeling continuous sequences of data without consuming all the space it may need.

Everything we've played with so far has been simple and pure. Unlike those disobedient effects passing notes to each other, non-deterministically. Oh I hate them so much.

Can effects be more like that?

Close your eyes. No, seriously, close them. This is important. Now, imagine a world where all your effectful code could just be designed as data structures! Are your eyes still closed? Good. Something as simple as a linked list that describes all the effectful logic in your code. Writing tests will become fun! Everything would be so much simpler. All of our life's problems would just disappear.

Well, today's yo... Oh you can open your eyes now. Sorry. Well, today's your lucky day!

We will turn your ill-mannered effects into well behaved pure data structures.

Impure effect? More like code neglect, amirite? Please clap

Kids, please turn in your assignment from last week. I hope you all implemented appendStringToFile: string => string => string that appends a string to a file and returns the new contents, given the imaginary synchronous functions readFile: string => string and writeFile: string => string => () for doing file IO.

let appendStringToFile = (fileName, logLine) => {
  let contents = readFile(fileName)
  writeFile(contents ++ logLine)
  readFile(fileName)
}

let newLogContents = appendStringToFile(fileName, "\nSome text")

Oh my god, Timmy! Is that imperative and impure function calls in your notebook? That's it. To the principals office! Now!

Now let's try to think of a way to do this that's not an absolute nightmare to test. What if we just made a data structure out of it?

Let's try turning each of those statements into variants that can be linked together lazily.

type rec fileEff<'a> =
  | ReadFile(string, string => fileEff<'a>)
  | WriteFile(string, string, unit => fileEff<'a>)
  | Return(string)

let appendStringToFile = (fileName, logLine) =>
  ReadFile(fileName, contents =>
    WriteFile(fileName, contents ++ logLine, _ =>
      ReadFile(fileName, newContents =>
        Return(newContents))))

You can read Something(a, b, c => fileEff<'a>) as an operation Something that takes a and b and returns a c.

If you squint hard enough, you'll find that this is very similar to the lazy list data structure we implemented earlier. You have the last item Return, and each item before it is a description of an effect.

This is similar to how programming languages have Abstract Syntax Trees (AST) that describe the syntax of the language which then goes through the interpreter to be executed. Just like ASTs, to get our code working, we need to write an interpreter to evaluate our data structure and produce effects.

let rec interpreter = eff => switch eff {
  | Return(contents) => contents
  | ReadFile(fileName, getNext) =>
    readFile(fileName)->getNext->interpreter
  | WriteFile(fileName, contents, getNext) => {
    writeFile(fileName, contents);
    ()->getNext->interpreter;
  }
}

let result = interpreter(appendStringToFile("./file", "hello world"));

The interpreter walks through the list-like structure and calls itself recursively on each of the nodes till it hits Return.

Kevin: "Why is this better than writing it imperatively?"

*takes a deep breath* Kevin... STFU!

This is better because it decouples your business logic from the effects! This is better because you can just create a mock interpreter and write tests for your business logic without actually generating effects! This is better because you get dependency injection for free!

Are we composable yet?

Now we have a new problem though. It seems like Return will have to be defined for every kind of effect we may have. This will also make it difficult to compose it with other effects. So let's abstract that out.

We can create a module function for creating effects and handling the recursion in the interpreter.

module type EFFECT = {
  type t<'a>
}

module MakeEffect = (Eff: EFFECT) => {
  type rec t<'a, 'ret> = 
    | Return('ret)
    | Operation(Eff.t<t<'a, 'ret>>)

  let rec interpreter = (eff, handler) => switch eff {
    | Return(x) => x
    | Operation(m) => handler(m)->interpreter(handler)
  }
}

Then we can rewrite our file effect in peace.

module FileOperations = {
  type t<'a> =
    | ReadFile(string, string => 'a)
    | WriteFile(string, string, unit => 'a)
}

module FileEffect = MakeEffect(FileOperations)

let appendStringToFile = (fileName, logLine) => {
  open FileOperations;
  open FileEffect;

  Operation(ReadFile(fileName, contents =>
    Operation(WriteFile(fileName, contents ++ logLine, _ =>
      Operation(ReadFile(fileName, contents =>
        Return(contents)
      ))
    ))
  ))
}

let handler = eff => switch eff {
  | ReadFile(fileName, resume) => readFile(fileName)->resume;
  | WriteFile(fileName, contents, resume) => {
    writeFile(fileName, contents);
    resume(());
  }
}

let result = appendStringToFile->FileEffect.interpreter(handler)

"Effects as a data structure is cool and all but I don't want to write code that looks like a ladder" - Former student who died under suspicious circumstances shortly after making this statement

I get it. It looks ugly. All new-born babies do. We just need some SYNTAX SUGAR to make things better. Don't worry tho. I got you. But before we go there, we need to implement a flatMap operation for our effect.

You may know flatMap from it's critically acclaimed role in Belt.Option and Belt.Result modules. Also, the horrible Js.Promise.then_, is also a flatMap on promises. In general, flatMap: t<'a> => ('a => t<'b>) => t<'b> allows us to chain t<'a> to t<'b> using the result of t<'a>.

// This is a map operation over our file operation
let fileOpsMap = (eff, fn) => switch eff {
  | ReadFile(f, next) => ReadFile(f, e => e->next->fn)
  | WriteFile(f, c, next) => WriteFile(f, c, e => e->next->fn)
}

// This function allows us to chain our effects together
let rec flatMap = (eff, fn) => switch eff {
  | Return(a) => fn(a)
  | Eff(m) => Eff(m->fileOpsMap(flatMap(_, fn)))
}

While we're at it, we'll also need another function called liftEff. This function lifts any given operation into an Effect and makes it terminate with its result. x => next effect? becomes Eff(x => Return(x))

let liftEff = fa => Eff(fa->fileOpsMap(e => Return(e)));

Now putting it all together, our effects helper and file effect will look something like this

module type EFFECT = {
  type rec t<'a>;
  let map : t<'a> => ('a => 'b) => t<'b>;
};

module MakeEffect = (Eff: EFFECT) => {
  type rec t<'a> = 
    | Return('a)
    | Eff(Eff.t<t<'a>>);

  let liftEff = fa => Eff(fa->Eff.map(e => Return(e)));

  let rec flatMap = (eff, fn) => switch eff {
    | Return(a) => fn(a)
    | Eff(m) => Eff(m->Eff.map(flatMap(_, fn)))
  };

  let rec interpreter = (eff, handler) => switch eff {
    | Return(x) => x
    | Eff(m) => handler(m)->interpreter(handler)
  };
};

module FileOperations = {
  type rec t<'a> =
    | ReadFile(string, string => 'a)
    | WriteFile(string, string, unit => 'a);

  let map = (eff, fn) => switch eff {
    | ReadFile(f, next) => ReadFile(f, e => e->next->fn)
    | WriteFile(f, c, next) => WriteFile(f, c, e => e->next->fn)
  };
};

module FileEffect = MakeEffect(FileOperations);

// Lifted helper functions
let readFileOp = file =>
  FileEffect.liftEff(FileOperations.ReadFile(file, x => x));

let writeFileOp = (file, contents) =>
  FileEffect.liftEff(FileOperations.WriteFile(file, contents, x => x));

Now for the SYNTAX SUGAR I promised!

let appendStringToFile = (fileName, logLine) => {
  open FileEffect;

  readFileOp(fileName)
  ->flatMap(contents => writeFileOp(fileName, contents ++ logLine))
  ->flatMap(_ => readFileOp(fileName))
};

We have turned our FileOperations into a functor

No, not that functor, the other functor.

Functors in ocaml (module functions) are very different from functors in category theory.

What we have made here is a combination of both kinds of functors. The FileOperations functor (category theory) goes into the MakeEffect functor (module function) and returns FileEffect monad (category theory).

Fun fact: Functor comes from the contraction of, fun which is Russian for vodka, ca which of course is the sound a crow makes and tor which is a modern tin foil hat that actually works.

Fun fact: Monad comes from the mind of a mathematician who forgot about the essay that was due, so at the last minute, started making up words to fill up the 800 words.

Don't quote me on that but it's probably true. We'll never know.

We don't have to get into the specifics of functors and monads to make sense of this class but it is worth the learning curve.

Ugh.. Unit tests

Writing tests for it is as simple as creating a mock handler.

let mockFile = ref("init:");
let mockHandler = eff => switch eff {
  | FileOperations.ReadFile(fileName, resume) => resume(mockFile.contents);
  | FileOperations.WriteFile(fileName, contents, resume) => {
    mockFile.contents = contents;
    resume(());
  };
};

let result = appendStringToFile("./file", "text to append")
  ->FileEffect.interpreter(mockHandler);

expect.string(result).toEqual("init:text to append");
expect.string(mockFile.contents).toEqual("init:text to append");

And now for the best part... drum rolls

SNAPSHOT/GOLDEN TESTING

Yes! As all our business logic is now just a data structure, you can create a snapshot of it to test against!

You can perform snapshot testing of your effect by accumulating the effects called on your handler as an array.

let nodes = ref([]->Obj.magic);
let addNode = node => nodes.contents = nodes.contents->Belt.Array.concat([node]);

let mockHandler = eff => {
  addNode(eff);
  switch eff {
    | FileOperations.ReadFile(_f, resume) => resume("mock file contents")
    | FileOperations.WriteFile(_f, _c, resume) => resume(())
  };
};

appendStringToFile("./file", "text to append")->FileEffect.interpreter(mockHandler)->ignore;

expect.value(nodes).toMatchSnapshot();

And just like that, all of our business logic is now 100% safe against all kinds of refactor.

• You change the order of effects?... Tests break!
• You add another effect in between?... Tests break!
• You accidentally delete everything?... Tests explodes!
• You got scammed by a Nigerian prince?... This won't help with that!
• You change something that doesn't impact your program?... Tests pass!

Effect composition

File IO is great but your code will involve other effects too. Maybe you want to implement logging? Or maybe some caching mechanism? Or maybe you just want to maintain a piece of mutable state in your code? Just having one effect called FileEffect is not gonna cut it.

To be able to compose multiple effects into one big effect, we can use the almighty STRUCTURAL/POLYMORPHIC VARIANTS!

// File IO effect
module FileOperations = {
  type rec t<'a> = [ #ReadFile(string, string => 'a) | #WriteFile(string, string, unit => 'a) ];

  let map = (eff, fn) => switch eff {
    | #ReadFile(f, next) => #ReadFile(f, e => e->next->fn)
    | #WriteFile(f, c, next) => #WriteFile(f, c, e => e->next->fn)
  };
};

// Logger effect
module LoggerOperations = {
  type rec t<'a> = [ #LogMessage(string, string, string => 'a) ];

  let map = (eff, fn) => switch eff {
    | #LogMessage(m, d, next) => #LogMessage(m, d, e => e->next->fn)
  };
};

// Composition of FileOperations and LoggerOperations
module MyCustomOperations = {
  type rec t<'a> = [ LoggerOperations.t<'a> | FileOperations.t<'a> ];

  let map = eff => switch eff {
    | #...FileOperations.t as e => FileOperations.map(e)
    | #...LoggerOperations.t as e => LoggerOperations.map(e)
  };
};

module MyCustomEff = MakeEffect(MyCustomOperations);

let logMessageOp = (message, data) => MyCustomEff.liftEff(#LogMessage(message, data, x => x));
let readFileOp = file => MyCustomEff.liftEff(#ReadFile(file, x => x));
let writeFileOp = (file, contents) => MyCustomEff.liftEff(#WriteFile(file, contents, x => x));

// Our program
let appendStringToFile = (fileName, logLine) => {
  open MyCustomEff;

  readFileOp(fileName)
  ->flatMap(logMessageOp(":: Logging file contents before update -"))
  ->flatMap(contents => writeFileOp(fileName, contents ++ logLine))
  ->flatMap(_ => readFileOp(fileName))
  ->flatMap(logMessageOp(":: Logging file contents after update -"))
};

You can compose any number of effects together into one for your programs!

And of course, nothing would work without the handler so...

let handler = eff => switch eff {
  | #LogMessage(message, data, resume) => {
    Js.log2(message, data);
    resume(data);
  }
  | #ReadFile(fileName, resume) => readFile(fileName)->resume;
  | #WriteFile(fileName, contents, resume) => {
    writeFile(fileName, contents);
    resume(());
  };
};

let result = appendStringToFile->MyCustomEff.interpreter(handler);

Does all of this have a name?

What we just learned is a construct in functional programming called free algebraic structures. More specifically, FileEffect and MyCustomEff are Free Monads.

In general, a free monad on a Functor f is a structure where each node represents f. If you understood what I just said, please explain it to me after class so I don't look like an idiot in front of my other students.

In this class, we used it to fold (interpret) a data structure to generate effects. It allowed us to decouple the composition of our effects with the effect's behavior by creating a pure representation of our computations.

Free monad implementation for dealing with effects in such a way is also referred to as algebraic effects.

To learn more about this, you could walk through the following links -

• What the fuck are module functions/functors?
• What the fuck is a Functor in category theory?
• What the fuck is a Monad?
• What the fuck are Free Algebraic Structures?
• What the fuck are algebraic effects?

Report card

Our jobs as programmers is to create as many guarantees in our code as possible. To achieve this, we should always try to design things in a way that pushes everything we can't guarantee to the edges.

This not only reduces the surface area for bugs, but also reduces the mental overhead to the person reading the code.

This is why we should always try to minimize the surface area of impurity in our code.

With free monads, we create a guarantee that our business logic is sound and we push the effects to the edge in the form of our interpreter since we may not be able to guarantee the correctness of effectful behavior.

Anyways, impure programs get a C for "Can do better". Almost-pure programs with Free monads, get an A for "Aahaaa, functional programming wins again".

Alright kids, get a signature on the report card from your parents. No fake signatures, John. Those squiggly lines aren't fooling anyone.

My name is Houdini J.S. Magnifico. What I'm about to perform here are a set of illusions and magic tricks that are sure to blow your mind! So prepare to be amazed!

The tricks shown here are performed by trained professionals. Do not attempt these stunts at home. Do it in production. Viewer discretion is advised.

Let the show begin!

For my first trick, I will make this function… DISAPPEAR!

This is my totally normal function. Nothing weird about it. A function you'd find in the wild.

typeof innocentTotallyNormalFunction === "function" // > true

Let me just wave Brendan Eich's mouse pad over it for a bit… and… BOOM!

innocentTotallyNormalFunction()
// > Uncaught TypeError: innocentTotallyNormalFunction is not a function

GONE! The function is not a function anymore. Schrodinger's function has dissappeared!

audience applauds

Thank you! Thank you!

Here's how it works

const innocentTotallyNormalFunction = (() => {}).apply.bind();
// Works with any method's bind();

Weird right? It's called JavaScript and a lot of people use this in production. The reason this doesn't work is because .apply method expects the context of a function but .bind gives it undefined as the context. this.means that the apply method doesn't know which function it is trying to apply. Then the apply method has an identity crisis and everything goes to shit.

Magic list

Here I have a function that clones an array. Perfectly normal, production ready code.

const clone = list => list.reduce((newList, item) => [...newList, item], []);

// Another clone implementation you can use is,
const clone = Object.values;

// Or if you wanna go old school...
const clone = list => {
  const newList = [];

  for(let index in list) {
    newList.push(list[index]);
  }

  return newList;
};

Here's an ordinary list with nothing fishy going on inside

array.length // > 23

I'm just gonna casually use the clone function to copy the list and check the length of the newly created list…

clone(array).length // > 1

Magic!!

The list is no longer 23 items long. 23 to 1! Next-gen compression algorithm, question mark? Or is it just magic?

Well, here's how it all went down

The concept behind this is one that not many developers are familiar with. Array holes, also called empty slots are points in an array that are empty. No, I'm not talking about undefined or null or 0. Just empty.

Ref: Array holes/empty slots, Sparse arrays

Array(5) // > [<empty x 5>]
// OR
[,,,,,] // > [<empty x 5>]

This creates an array of 5 items but without any values. But javascript doesn't use undefined as the default values tho. It instead creates empty slots (holes) in the arrays but keeps given the length. So when you copy it using the reduce method, it doesn't iterate over the empty slots. So the newly generated array is shorter.

Schrodinger's magic list

The list we are gonna be working on is document.all which is a list of all nodes in a document.

document.all // > HTMLAllCollection {...}

Council of W3C, give me the strength to make this list disappear!!! Boom! Shaa! Waka-Waka Boom!

typeof document.all // > undefined

Be Amazed!!

Go get an MRI scan because your tiny little brain just exploded!

Here's the big reveal!

document.all is a very old and deprecated api that allowed you to iterate over all the nodes rendered to the DOM. The typeof expression returning undefined was by design as a part of deprecation of that non-standard feature. Weird, I know. But that's just how javascript rolls.

Are we Infinity yet?

Let's take a number, let x: number.

x + 1 === x; // >> true
x + 2 === x; // >> false

“What just happened?”

I added 1 to x and the value didn't change! Then I added 2 to it and… the universe… it changed.

Check out how this works

const x = 1e16; // OR 1 * Math.pow(10, 16) OR 10000000000000000

This is by design. It's documented in IEEE 754-2008. When the number is as large as this, it rounds it up to the nearest even number.

Ref: Rounding rules section in IEEE 754

Is a “not a number” a number or not a number? Well, it's NaN of your business

typeof NaN === 'number' // >> true
NaN !== NaN // >> true

Wut? ‘Not a number' is a number and ‘Not a number' is not equal to ‘Not a number'

Javascript is a magical language

Know the trick

NaN is a numeric data type but it behaves as an identity when any mathematical operation is applied to it.

“But why is NaN === NaN returning false?”

Because the Gods of Javascript wished so. If either side of === operator is NaN, the operation returns false. Thats just how it works. Don't question it.

Check if your list has more than 1 items

A very complicated problem in programming.

A normie dev would go ahead and write something like

const hasAtleast2Elements = x => x.length >= 2;

That solution is 13 characters long. In the modern world of javascript, 13 characters is way too many characters. It is a performance bottleneck.

Let's write something more optimized in size

const hasAtleast2Elements = x => !isNaN(+x);

There. 10 characters. Much better. We removed 23% of our JavaScript! Good job. Less JavaScript is good JavaScript

The genius behind this action

We improved our load time by 23% but at what cost?! How does that function even work? Magic? Not magic, JavaScript!

The + operator applied to a list returns NaN if the number of items in the list is more than 1.

Why does it do that? Well, type casting. +[] is equal to +[].toString().

So,

[].toString() === '' // >> +'' === 0
[1].toString() === '1' // >> +'1' === 1
[1, 2].toString() === '1,2' // >> +'1,2' === NaN (Cannot typecast as it is not a number)

That's all for today! Tune in next time to watch Magnifico use magic in production and get fired immediately.

Now I'm gonna make myself disappear.

…

…

…

Why is this… Just a second folks… Some technical difficul…

magic man magically disappears

Welcome to my Grandma's Kitchen. I'm your host, the grandson. Let's start cooking, shall we?

Disclaimer: Stuff referenced in this post are not my opinions, they are straight up facts. If you disagree, you're probably right but don't tell anyone. Reader discretion is advised.

For far too long have we suffered the torture of writing boilerplate code and messy actions. Not anymore. Here are some recipes to cook redux the way my grandma wants you to.

We are going to be cooking with the following ingredients today -

• Redux Saga
• Redux Utils
• Crocks
• Reselect
• Ramda (optional. Add according to taste)

Spicy hot action names/types

You wouldn't expect there to be any changes in the way you create action names/types but why not? Go check your action types file. You will find that there is a recurring pattern of the three states. ACTION_PENDING, ACTION_SUCCESS and ACTION_FAILURE (not FAIL because PENDING, SUCCESS and FAILURE have the same number of characters and my grandma likes consistency). And while we are at it we can also learn something from the REST architecture from my grandma's time and bring the resource/action pattern in here.

actionTypes function uses the @resource/ACTION/STATE convention.

import { actionTypes } from '@phenax/redux-utils';

const types = actionTypes({
  DISHES: {
    LIST: ['PENDING', 'SUCCESS', 'FAILURE'],
    ADD: ['PENDING', 'SUCCESS', 'FAILURE'],
  },
  SESSION: {
    INIT: ['PENDING', 'SUCCESS', 'FAILURE'],
  },
});

types.DISHES.ADD.SUCCESS === '@dishes/ADD/SUCCESS'; // true

// Your actions will then look something like
dispatch({
  type: types.DISHES.ADD._,
  payload: {
    name: 'Chicken that tastes like paneer',
    ingredients: {
      chicken: { count: 1, unit: 'bird' },
      salt: { toTaste: true },
      pepper: { count: 2, unit: 'shakes' },
      milk: { count: 3, unit: 'seconds of pouring' },
    },
  },
});

// The underescore (`._`) is the dispatch that gets picked up by the sagas. Its a default dispatch i.e. stateless dispatch.

Reducer salad

The three state pattern is also seen repeated a lot inside reducers. My grandma keeps telling me “My back hurts when I scroll through long switch-case statements”. So if you haven't guessed already, we are going to change that too now. We have to care for the elderly.

import { createPartialReducer, mergeReducers } from '@phenax/redux-utils';

const initialState = { loading: false, readyForServing: true, dishes: [], error: "" };

const getLoadingState = state => ({ readyForServing }) => ({
  ...state,
  readyForServing,
  loading: true,
});

const addDishReducer = createPartialReducer(types.DISHES.ADD, (state = initialState, action) => ({
  PENDING: getLoadingState(state),
  SUCCESS: newDish => ({
    ...state,
    readyForServing: true,
    loading: true,
    dishes: [...state.dishes, newDish],
  }),
  FAILURE: e => ({
    ...state,
    readyForServing: false,
    loading: true,
    error: e.message,
  }),
}));

// Your regular reducer can be merged with partials
const regularOldReducer = (state = initialState, action) => {
  switch(action.type) {
    case types.SOMEOTHER.ACTION.PENDING:
      return {
        ...state,
        loading: true,
      };
    case types.SOMEOTHER.ACTION.SUCCESS:
      return {
        ...state,
        loading: false,
        dishes: [],
      };
    case types.SOMEOTHER.ACTION.FAILURE:
      return {
        ...state,
        loading: false,
        dishes: [],
        error: e.message,
      };
  }
};

export default mergeReducers(addDishReducer, regularOldReducer);

The partial reducers allow you to split the reducer into smaller functions based on the resource/action/state convention. You can also use this to show off your rad point-free trick shots.

Duck promises

There are 3 different ways to interpret name of this dish. Clue, it's not a typo (even though it fits perfectly). Another clue, we're not cooking a duck here. You are correct. Just duck those promises and go with Async from crocks. (Not to be confused with async/await which is just a prank that the C# community is playing on us disguised as w3c draft authors). Here's how to use fetch (or any other promise based api) and turn it into a composible, cancellable, lazy Async task. Grandma does not approve laziness but we will use it anyway because GOD DAMMIT, IT'S MY FREAKING COOKING SHOW! GET OUT OF MY ROOM, GRANDMA!

For you, a simple made-up example of fetching with network timeout. fetchJson is just an Async wrapper for fetch api.

import Async from 'crocks/Async';
import { prop, filter, map, either, complement } from 'ramda';
import { fetchJson } from '@phenax/redux-utils/async';

// Some other api call that happens after we get the data from the user
// fetchChefInfo :: a -> Async a
const fetchChefInfo = data => Async((rej, res) => setTimeout(() => res(data), 700));

// fetchServableDishes :: Object * -> Async [User]
const fetchServableDishes = params => fetchJson('/dishes', params)
  .race(Async.rejectAfter(2000, new Error('Request Timeout')))
  .map(prop('dishes'))
  .map(compose(
    filter,
    complement,
    either(
      prop('isReady'),
      prop('isBurnt'),
    ),
  ));

let task = fetchServableDishes();

// The request has not been sent yet (it's lazy like crazy! Thank you. Thank you.). You can keep composing and chaining stuff
task = task
  .map(map(decorateDish))
  .chain(fetchChefInfo);

// And when you finally decide that you want to make the api call, you can fork it.
// Nothing is executed till you call .fork
task.fork(
  e => console.error(e),
  activeUsers => {
    // Do stuff
  },
);

Barbecue sagas

Redux saga is the best way to write actions. That is a fact, not an opinion. No need to look it up. Not going to change anything with that but we can add a few ingredients to enhance its flavor. We are also going to use Async instead of Promise because my grandma believes you shouldn't make promises you can't keep/manage.

import { put } from 'redux-saga/effects';
import { callAsync, putResponse } from '@phenax/redux-utils/saga';

export function* add({ payload }) {
  yield put({ type: types.DISHES.ADD.PENDING, payload: {} });
  const response = yield callAsync(saveNewDish, payload);
  yield putResponse(types.DISHES.ADD, response);
};

export function* list({ payload }) {
  yield put({ type: types.DISHES.LIST.PENDING, payload: {} });
  const response = yield callAsync(fetchServableDishes);
  yield putResponse(types.DISHES.LIST, response);
};

export default function* root() {
  yield all([takeLatest(types.DISHES.ADD._, add)]);
  yield all([takeLatest(types.DISHES.LIST._, list)]);
};

Here,

yield putResponse(types.DISHES.LIST, response);
// is just a shorthand for
yield put(response.cata({
  Success: data => ({ type: types.DISHES.LIST.SUCCESS, payload: data }),
  Failure: error => ({ type: types.DISHES.LIST.FAILURE, payload: error }),
}));

Selector noodles

Selectors allow you to derive your data from the state and memoize the operation. We are going to use reselect for this and we're also gonna sprinkle some ramda in there according to taste. You can use lodash too but why would you do something like that? Ramda is to lodash what a smart watch is to a tin-can telephone.

Grandma: “Back in my day, underscore was pretty popular. It was like…”.

Yeah grandma, we get it, you're old. Now shut up and let me show these people some selector action.

import { createSelector } from "reselect";
import { pathOr, prop, __, map } from 'ramda';

// selectBurntDishes :: { dishes :: { dishIds :: [String], items :: Object Profile } } -> [String]
export const selectBurntDishes = createSelector(
  pathOr({}, ['dishes', 'items']),
  pathOr([], ['dishes', 'dishIds']),
  (items, dishIds) => dishIds.filter(compose(
    prop('isBurnt'),
    map(prop(__, items)),
  )),
);

Now you can use it anywhere…

In you component's mapStateToProps,

const mapStateToProps = state => ({
  burntDishes: selectBurntDishes(state),
});

export default connect(mapStateToProps)(ListBurntDishes);

In your sagas,

function* mySaga() {
  const burntDishes = yield select(selectBurntDishes);
  // Do stuff with those ids
}

Doesn't that look pretty? If you're new to the point-free way, you may feel like you just watched a french movie without subtitles but trust me, this is worth the confusing first few days.

Conclusion

Old ideas and opinions are what new ones are born from. Grandma's recipes were great and they've come out of experience that doesn't mean we have to keep making the same thing a billion times. Small (and sometimes large) migrations are a good thing.

So let's summarise. What did we learn today?

• Use grandma's favorite convention of @resource/ACTION/STATE for your action types
• The elderly hate long switch case statements
• Duck promises because Async rocks!
• Sagas are the freakin best!!
• Memoize those selectors for a better tomorrow

These are all solutions to the small yet annoying inconveniences that I ran into while working on a personal project of mine. I'm collecting all of the tiny helpers over at @phenax/redux-utils. The project is not done yet so the library will be getting more updates. PRs are welcome!!

Hope these ideas help you write some tasty code.

JavaScript has a very bad reputation in most developer communities. So much so that, “Writing cleaner and safer JavaScript…” in the title may already seem a bit redundant to most readers. A lot of that has to do with loose typing, invalid values and the horrible chain of ternary expressions or heaven forbid, if statements to handle them. With JavaScript, all functions run on the concept of “pretend what you are getting is what you asked for”. If the value is not valid for the kind of operation you are running on it, well, too bad. To save yourself from this, you can write run-time validations, add type-checks, etc but the core of the problem is till left largely unsolved.

Let’s learn from Haskell

Functional programming languages like Haskell have a clear solution for this. Sum Types! Sum Type (or Tagged Union) is an Algebraic Data Type which describes values that can take on several different types. Popular examples in haskell are the Maybe monad (for handling the validity of values) and the Either monad (for error handling).

Don’t worry. Maybe, I don’t know anything about monads Either (see what I did there?). All we need to know is that a Sum Type is a has multiple named constructors.

In Haskell, a Sum type looks something like this -

data MetalGenre = ProgMetal | DeathCore

scream :: MetalGenre -> IO ()
scream genre = putStrLn $ case genre of
  ProgMetal -> "Oh!"
  DeathCore -> "BleaAaAHHH!!"

main :: IO()
main = scream ProgMetal

Here, MetalGenre is the type and ProgMetal, DeathCore are constructors of that type.

A really popular and useful example of a Sum type in the functional world is the Maybe type. In Haskell, Maybe is a monad that wraps a value and helps you make sure that invalid values are not acted upon, thus allowing you to write safer functions.

This is what Maybe’s definition looks like in Haskell -

data Maybe = Just a | Nothing

Now here, all valid values will be wrapped in a Just and all invalid values will be wrapped in a Nothing. This way, we can handle invalid values in a clean and elegant way and be sure of the fact that the function is only called for the valid values.

You might be thinking, “But isn’t this only possible because Haskell is a statically typed beauty and JavaScript is the spawn of satan?”. Maybe it isn’t. (The joke’s getting old now)

EnumFP

Shameless self-plug alert!

I have a library to help with that! (Said every JavaScript developer ever).

EnumFP (PRs welcome)

EnumFP is a simple and light-weight way to create Sum types in JavaScript. Inspired by the awesomeness of Haskell, the library is written with safety in mind.

This is what the metal genre example would look like with EnumFP.

const MetalGenre = Enum(['ProgMetal', 'DeathCore'])

const scream = compose(console.log, MetalGenre.cata({
  ProgMetal: () => "Oh!",
  DeathCore: () => "BleaAaAHHH!!",
}));

scream(MetalGenre.ProgMetal());

Maybe, maybe?

The concept of what a Maybe does is more important than the implementation itself. Containing a value in a way that allows you to perform a set of operations on the container and not worry about the validity of the input is what Maybe is about.

You can implement a simple Maybe and a couple of utility functions using EnumFP. EnumFP also allows you to add argument descriptions. This example uses the caseOf function which is like match but for partial application).

const Maybe = Enum({ Just: ['value'], Nothing: [] });

// fmap :: (a -> b) -> Maybe a -> Maybe b
const fmap = fn => Maybe.cata({
  Just: compose(Maybe.Just, fn),
  Nothing: Maybe.Nothing,
});

// mjoin :: Maybe Maybe a -> Maybe a
const mjoin = Maybe.cata({
  Just: x => x,
  Nothing: Maybe.Nothing,
});

// chain :: (a -> Maybe b) -> Maybe a -> Maybe b
const chain = fn => compose(mjoin, fmap(fn));

Here,

fmap returns a new Maybe and runs the function over the value inside, in case of Just and ignores a Nothing. (Like Array.prototype.map)

mjoin unwraps a given nested Maybe. Because many monads like Maybe, are agnostic about the value inside, you can put the monad inside another monad (That’s what shesaid) (Like Array.prototype.flatten)

chain maps over the Maybe and then flattens the resulting nested Maybe. (Like Array.prototype.flatMap).

Let’s use this and write a function that accepts a User instance and gives you the first name without throwing an error for invalid user or invalid name.

// head :: [a] -> Maybe a
const head = arr => (arr.length ? Maybe.Just(arr[0]) : Maybe.Nothing());

// prop :: String -> Object a -> Maybe a
const prop = key => obj => key in obj ? Maybe.Just(obj[key]) : Maybe.Nothing();

// trim :: String -> String
const trim = str => str.trim();

// split :: String -> String -> [String]
const split = seperator => str => str.split(seperator);

// safeUser :: User -> Maybe User
const safeUser = user => isUserValid(user) ? Maybe.Just(user) : Maybe.Nothing();

// getFirstName :: User -> Maybe String
const getFirstName = compose(
    chain(head), // Maybe [String] -> Maybe String
    fmap(split(' ')), // Maybe String -> Maybe [String]
    fmap(trim), // Maybe String -> Maybe String
    chain(prop('name')), // Maybe User -> Maybe String
    safeUser, // User -> Maybe User
);

Maybe.match(getFirstName(user), {
    Just: name => console.log('My name is', name),
    Nothing: () => console.log('Whats in a name?'),
});

In the example above, we first convert the user to a safe user by wrapping it in a Maybe. Then we get the user’s name using the prop function. The prop and head functions here, instead of returning the value, wraps the value in a Maybe. This is why to map it and then unwrap it, we use chain instead of fmap.

Working with React

Yes, EnumFP works well with react! (Jumping from one over-populated community to the next).

With the new react hooks being introduced in 16.8, it would be a sin not to mention it here. EnumFP ships with a useReducer hook which is a simple wrapper around react’s useReducer.

Don’t want to upgrade to 16.8? Do you still watch reruns of Seinfeld? Want to wait for your grand-children to help you with the upgrade… and… walking?

No worries. There’s an HOC available as well.

You can find out more about integrations with react here.

And this is not limited to just component state tho. You can use Sum Types to work with any kind of enumerable state values. From handling Success, Pending and Failure states for any action to containing values based on it’s type or validity. Sum Types are here to clean up all of that.

Conclusion

This is just the tip of the iceberg. There are a lot more of these amazing ideas hidden in the world of functional programming, waiting to move to other languages. Being a part of the JavaScript community for a while has made me realise that it’s not all bad. What we lack in language features and standard library, we make up for in the variety of libraries just an npm install away, and the strong community constantly working towards “Making JS great again”. So let’s build a wall together between us and bad code. Covfefe.

Yep. No doubt about it. I love another remedy game. Who would've thought, Control: resonant is brilliant. How creative they were in exploring the Jesse, Dylan relationship. How they explored everything the set up in Control about their childhood, Dylan's time in containtment, etc. How deserved the transition feels from Dylan being hated by everyone for the things he did in Control, to gaining the respect of everyone at FBC. They humanized him the right way with guilt weighing him despite the fact he wasn't in "control" of his actions in Control.

The world they set up feels very real despite the absurdity of that statement. They've poured so much detail into every concept that I felt guilty traversing throught it quickly because I didn't get to pay enough attention.

And don't get me started on the gameplay. Smooth traversal like the original Control. Much more difficult than control but thats only a motivation to spend time with the upgrades and exploring more side quests. A decent variety of memorable bosses too. Chefs kiss for striking the right balance. Although I did cheat a couple of times by using the accessibility settings to increase damage a bit.

The only complain, the god damn taxi disappointment. Amazing build up and really fun puzzles but the ending of the taxi quest was so damn unsatisfying. Nitpick considering everything else the game gets absolutely right.

Another hit as expected. This Sam Lake guy and his team know what they're doing. More please of this.

GTA6 can spit in your mouth, fuck your wife, kill your dog and you'll still pay that $100 price tag on release. Rockstar could've priced it at the steam machine price and people would complain less.

We're all just weak, pathetic consumers waiting to suckle at the bosom of Rockstar. The best we can do in the form of a protest is to wait for a sale but you can't resist, can you?

At this point, I truely wish, the game sucks and people stop playing it after a week but a man can only dream.

Going to fan boy this one because I love every single remedy game that has come out so far (except firebreak). They make truly original and creative... uh calling them games feels wrong. Tempted to call them "interactive cinematic experiences" at the cost of sounding like an asshole.

• Control has a fantastic story and is extremely fun to play.
• Alan wake 2 was a huge improvement over alan wake 1 (and american nightmare) which was my favorite game before the sequel came out.
• Quantum break was also fun to play and watch (because it's a game with a TV show embedded within it).
• Old max payne games are amazing too and still fun to play even with it's stiff, tiny bit outdated controls.

This is what remedy does best and why I like them. Those finnish bastards make amazing story-driven games and take creative risks to make their work more interesting. Unlike activision's (treyarch, infinity ward, sledgehammer, etc included) creatively bankrupt and completely hollow almost-yearly call of duty releases, remedy consistently produces quality games. You can say "apples to oranges" but I say "fruit to fruit". Need a little bit of this in every team in the world building things. Not everything needs to be done with the goal of feeding profit piggy.

Have fun with it. Make interesting things.