tonymorris

data Hi =
  Hi1 Int
  | Hi2 String
  | Hi3 [Int]
  deriving (Eq, Show)

-- generate this:
class AsHi a where
  _Hi ::
    a

tonymorris

1. As a pilot have you ever faced any hazards with glare:

• On a take off? If yes, please elaborate

  Yes. In a high-traffic class D airport with east/west runway orientation in the afternoon. I was mostly concerned with other traffic in the area.

  This has occurred on numerous occasions, but most hazardous during the airport's CTAF hours.

• On landing? If yes, please elaborate

  Yes. On arriving to the same airport from the east during late afternoon, sun glare caused me to have no visibility of the field at all, though I knew I was quite close. It was towered at the time. I chose to make a turn orthogonal to the sun so that I could sight the field and regain better situational awareness, then subsequently regain normal positioning.

tonymorris

{-# OPTIONS_GHC -Wall #-}

import Control.Monad(join)
import Data.List(foldl', permutations, sort)
import System.Environment(getArgs)

factorial ::
  Integer
  -> Integer
factorial n =

tonymorris

import Control.Applicative

data Costate a b =
  Costate {
    put ::
      a
      -> b
  , pos ::
      a
  }

tonymorris

import Data.Functor.Identity

data A = A
  deriving (Eq, Show)

data B = B
  deriving (Eq, Show)

data C = C
  deriving (Eq, Show)

tonymorris

Our web applications are getting increasingly more complicated. They are becoming more distributed and increasingly powered by combinations of complex, constantly changing and large datasets. All while users are increasingly more connected and want the latest information instantly without any slow page loads or stale information.

To address this, developers have turned to layers of caching and single page applications so that there are layers of aggregated and preloaded state as close to the user as possible, to be immediately available when it is requested. This comes at a high cost: it is very difficult to invalidate or update those caches when the upstream information changes. This is especially problematic when the stale caches can accidentally cause real bugs rather than show stale data to users.

The big issue here is that we're not just caching expensive-to-compute static data. We are caching data that changes over time. There are a number of architectual patterns that can be applied, but to date, n

tonymorris

• https://www.youtube.com/watch?v=DNMWdSpXd-M
• https://www.youtube.com/watch?v=klkAv74iK94
• https://www.youtube.com/watch?v=0_Xx5q5Cv8I
• https://www.youtube.com/watch?v=3rqhdvpxr4c
• https://www.youtube.com/watch?v=D_meReBqVxM
• https://www.youtube.com/watch?v=N0iQnVhwLnE
• https://www.youtube.com/watch?v=3csW955ObYc
• https://www.youtube.com/watch?v=94dRMq9e_IA
• https://www.youtube.com/watch?v=6t3MZzz-ISA
• https://ayvri.com/scene/095mxd00jz/cjwr1uug000011w5w7h93sxt4

tonymorris

https://www.youtube.com/watch?v=-dFE1WMsmWM

R1 01:09 R2 04:24

• heart 05:13 R3 07:25 R4 10:52 R5 15:41
• gold, while jumping, with sword 17:00 R6 18:22

tonymorris

{-# OPTIONS_GHC -Wall #-}
{-# LANGUAGE LambdaCase #-}

-- a leap year is a year, divisible by 4, except (those divisible by 100, except those divisible by 400)
-- there is no zero year

-- Distinguish leap years and common years in data types

import Control.Lens
import Data.Semigroup

tonymorris

{-# OPTIONS_GHC -Wall #-}

import Data.Semigroup
import Data.Functor.Contravariant

data List2 a =
  List2 [a] [a]
  deriving (Eq, Ord, Show)

instance Semigroup (List2 a) where