eborden

#!/usr/bin/env stack
-- stack --resolver nightly-2017-08-20 --install-ghc runghc --package compact
{-# LANGUAGE ExistentialQuantification #-}
module Main where

import Data.Compact

class SomeClass a where
  someId :: a -> a

eborden

module Main (main) where

import qualified Control.Foldl      as Fold
import           Criterion.Main
import qualified Data.List
import           Data.Maybe
import           Data.Semigroup

naiveAvg, foldMapAvg, foldlAvg, foldAvg :: [Float] -> Float
naiveAvg xs = Prelude.sum xs / fromIntegral (Prelude.length xs)

eborden

#!/usr/bin/env stack
-- stack --resolver lts-9.8 script
module Main where

import Data.Functor (void)
import Data.Foldable (traverse_, for_)
import Data.Traversable (for)
import Control.Concurrent (forkIO, readChan, writeChan, newChan, getNumCapabilities)
import Control.Immortal (create, wait, Thread)

eborden

[Unit]
Description=Stretching Reminder

[Service]
User=username
Environment=DISPLAY=:0
Type=oneshot
ExecStart=/path-to/stretch.sh

eborden

import Control.Monad (guard)
import Data.Bifunctor (second)
import Data.Foldable (for_, traverse_)
import Data.List (nub, permutations, unwords)
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Maybe (fromMaybe)


test :: IO ()

eborden

$ ./take-throw-test.hs
with
m
...
with
m
with
m
with
m

eborden

project=$(basename "$(pwd)")

# build dependencies
build_deps="stack build $project --fast --pedantic --dependencies-only --interleaved-output"

# restart on changes in other packages
restarts=$(find ../. -maxdepth 1 -type d \
  -not -name "$project" \
  -not -name .stack-work \
  -not -name . \

eborden

{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE NamedFieldPuns #-}

module Control.Concurrent.FreshVar
  ( FreshVar
  , newFreshVar
  , newPreemptiveFreshVar
  , readFreshVar
  )

eborden

IMHO, Kanban and SCRUM attempt to achieve the same goal, throughput. However they put systemic pressure on different points of organizational breakdown.

SCRUM takes the stance that communication is where throughput suffers. Without effective communication, via iterative planning, efficiency is lost.

Kanban believes focus is the point of efficiency loss. By moving tasks through work limited stages a team gains laser focus which should encourage high throughput.

That doesn't mean that SCRUM doesn't value focus. It utilizes story points and velocity to encourage tightly focused iterations.

Nor does Kanban ignore communication. Boards communicate work status and well designed work in progress limits on your board should encourage communication and collaboration amongst team members.

eborden

A journey down the strange hole that was Thomas Middleditch's chip reviews.

1. https://www.instagram.com/p/Bh7J4QojTH5/
2. https://www.instagram.com/p/BjdtwKQD-XD/
3. https://www.instagram.com/p/BjgW6vQDDEN/
4. https://www.instagram.com/p/BjjCl7eDUIf/
5. https://www.instagram.com/p/BkbQ36vj6mV/
6. https://www.instagram.com/p/BkdmXDgjKl2/
7. https://www.instagram.com/p/BkjLdZyDhXX/
8. https://www.instagram.com/p/BklhSeEDVlD/