new post

posts/what_easy.md

@@ -0,0 +1,134 @@
+---
+title: "Easy after you \"get it\""
+
+description: ""
+
+date: "2025-01-25"
+
+draft: true
+
+tags: []
+---
+
+I feel like there's a bunch of things out there which aren't "easy" until you get some crucial insight(s).
+Am I the first person to realize this?
+No, it's even probable that I read/heard this somewhere before and forgot.
+Either way I wanted to ramble about some things which I find easy but seem to not be and things which I find hard but think will become easy with some critical insight(s).
+
+## Easy for me and not(?) for people not in the loop
+
+### Recursion
+
+Solving a problem with recursion can fundamentally be described with the following steps.
+
+1. Find a case where you know the solution without recursion and solve it. Often this will be the simplest case.
+2. Figure out a way to solve the problem if you know the solution for a slightly simpler case
+
+Well... actually, while that is useful for solving arbitrary homework problems it's not how I use recursion in practice.
+Generally when I do recursion it's as a convenient way to perform a [depth first search](https://en.wikipedia.org/wiki/Depth-first_search).
+Okay might lose some people with that so here's an example.
+
+#### Example
+
+A few months ago I participated in a coding competition hosted by my university's branch of ACM.
+One of the problems in the competition can be paraphrased as follows.
+
+> Write a function that receives 3 inputs, `obstacles`, `minJump` and `maxJump`.
+> Where `obstacles` is a string cosisting of 0s and 1s and `minJump` and `maxJump` are positive integers.
+> Write a function to determine if there is a sequence of integers where all the integers are greater than or equal to `minJump`, less than or equal to maxJump and where making that sequence of skips (ie removing the first n chars from the string) will always have the first char of the string be "0" and will end with the final string being only a single char "0".
+
+Solving this problem was pretty easy, it was this
+
+```py
+# Scaffolding code provided wanted this function to return
+# "T" or "F" instead of True or False
+def escape(patch, minHops, maxHops):
+    if patch[0] == "1":
+        return "F"
+    if len(patch) == 1:
+        return "T"
+    
+    for i in range(minHops, maxHops+1):
+        if i >= len(patch):
+            break
+        if escape(patch[i:],minHops, maxHops) == "T":
+            return "T"
+    return "F"
+```
+
+All this does is
+
+1. check if we're in a known failure state and return appropriately
+2. check if we're in a known success state and return appropriately
+3. check to see if each of the jump lengths we can make can reach a success state and if so return appropriately
+4. if none of the lengths match return that this is a failure
+
+I don't know if the above insight or this example helps anyone or not.
+
+### Haskell Monads
+
+Not to be confused with [Category Theory Monads](https://en.wikipedia.org/wiki/Monad_(category_theory)).
+There's a running joke about how everyone who figures out Haskell Monads writes a tutorial on them, potentially including their own (probably incorrect) analogy.
+Fundamentally Haskell monads have 3 properties.
+
+1. They have an associated type, I'll be using `m<t>` to represent a type `m` with an associated type `t`
+2. They have a mechanism to turn a function with an input of type `a` and output of type `b` into a function with an input of type `m<a>` and output of type `m<b>` (derived from them being Haskell Functors, not to be confused with [Category Theory Functors](https://en.wikipedia.org/wiki/Functor) or [ML Functors](https://en.wikipedia.org/wiki/Standard_ML#Functors))
+3. They have a mechanism to turn a value of type `m<m<t>>` into a value of type `m<t>`
+
+If you're staring at Haskell documentation and confused on that third point, here's a definition of a flatten function.
+
+```hs
+flatten :: (Monad m) => m (m a) -> m a
+flatten v = v >>= id
+```
+
+Of course none of the above is the insight that I'm referring to, it's just to give the formally correct definition.
+The insight [can't be written into words](https://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/) unfortunately so instead I'm going to give a description of my intuition and maybe it helps, maybe it doesn't.
+
+Haskell Monads are just the shape you appease to be allowed to write procedural looking code via `do` syntax.
+Yeah that's it, they aren't really useful in other languages unless you want to generalize a procedural algorithm so it applies to data across many shapes.
+
+#### Example(s)
+
+##### IO
+
+`IO` is a special case in Haskell so it's worth understanding what it is separate from Monads generally.
+An `IO` object is basically a program that you can run which results in some value.
+`main` is just a special name for the program that gets run when you run the executable.
+The way a function is made to work on `IO` values is to just make it so the resulting `IO` value is now a program which takes the prior result and shoves it into the function you gave to give a new result.
+Flattening is just running the outer program to generate the inner program.
+For optimization reasons that's not how things actually work (I hope) but I don't want to dig into the compiler to give a more accurate answer.
+
+##### functions
+
+Yeah, normal functions are monads, specificaly the associated type is the return/output type.
+This fact is a counter example to the whole "Monads are types which wrap a value" thing btw.
+The way you do the whole function conversion thing is just function composition.
+The way you do flattening is
+```hs
+flatten f = \a -> (f a) a
+```
+that.
+
+##### lists
+
+A funny funky monad example which basically turns the `do` syntax into for loops.
+
+```hs
+-- basically turns [1,2] and [True, False] into
+-- [(1, True), (1, False), (2, True), (2, False)]
+myProduct :: [a] -> [b] -> [(a,b)]
+myProduct l1 l2 = do
+    elem1 <- l1
+    elem2 <- l2
+    -- return is just a function to turn a non-monad value into a monad value
+    return (elem1, elem2)
+```
+
+Changing functions is just a `map` and flattening is just well... exactly what you think when you flatten a 2d list into a 1d list.
+
+## Not easy for me, still need the insight
+
+### Finding a job
+
+This one