Peter Kjeld Andersen and-pete

Managing Haskell

blah blah blah more things here

From my experience fundraising in Haskell, companies who use it all seem to have suffered from the same two flavors of problem:

A rockstar comes in, dumps mindblowing code everywhere that dazzles the rest of the team and fools the product leads with pseudo-productivity until the rockstar leaves or finally wakes up. Cue the rest of the team death-marching for the next year or few years as the team attempts to juggle feature additions with excising or unraveling the impenetrable yarn-tangle of semantic misdirection.
An especially productive senior or team lead spends their time on refactoring and generally spinning their wheels with respect to product delivery, and then fails to deliver on time, or at all. Cue the rest of the team struggling to keep up with the refactors. The team's knowledge of the state of the product suffers, confusion about goals sets in, the senior/lead effectively becomes an anti-team player, throwing curveballs at the rest o

	module Main where

	import Prelude

	import Data.Array as Array
	import Data.FingerTree (FingerTree)
	import Data.FingerTree as FingerTree
	import Data.Lazy as Lazy
	import Data.Monoid.Additive (Additive(..))
	import Data.Newtype (class Newtype)

	{-# LANGUAGE DataKinds #-}
	{-# LANGUAGE PolyKinds #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE UndecidableInstances #-}
	{-# LANGUAGE UnsaturatedTypeFamilies #-}

	import GHC.TypeLits
	import Prelude hiding (Functor, Semigroup)

	type Main = (Fizz <> Buzz) <$> (0 `To` 100)

	{-# LANGUAGE DeriveGeneric #-}
	{-# LANGUAGE DerivingStrategies #-}
	{-# LANGUAGE FlexibleContexts #-}
	{-# LANGUAGE GeneralizedNewtypeDeriving #-}
	{-# LANGUAGE TemplateHaskell #-}
	{-# LANGUAGE TypeApplications #-}
	{-# LANGUAGE TypeOperators #-}
	{-# LANGUAGE UndecidableInstances #-}

	module Via where