gregberns

Notes from 2019-04-24 PHX DevOps meetup

Managing Secrets

NoDramaDevOps.com Blog

Platform Identity
* Can give a VM a service account which has rights to access 

* Use short term credentials to talk between services.

gregberns

fn partition<A,B>(list: Vec<Result<A,B>>) -> (Vec<A>, Vec<B>) {
    let mut aa = vec!();
    let mut bb = vec!();
    for i in list {
        match i {
            Ok(a) => aa.push(a),
            Err(b) => bb.push(b),
        };
    }
    (aa, bb)

gregberns

UniVerse Change Data Capture File Format

Below is a proposed data format to send UniVerse database changes via file. It uses standard UNIX delimiters for new lines, and standard UniVerse characters to deliniate fields (ASCII code 254 (þ)) and data (ASCII code 253 (ý)).

Example:

src=cssþns=CONTRACTSþts_ms=1550549470126þuid=12345678þop=uþdata=ý_id=1234ýname=Bobýþ
src=cssþns=CONTRACTSþts_ms=1550549470126þuid=12345678þop=uþdata=ý_id=1234ýname=Simonýþ

gregberns

module Lib
  ( someFunc
  ) where

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedStrings #-}

import           Hedgehog
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range

gregberns

interface Integer2Integer {
  int apply(int n); 
}
static int blah(Integer2Integer r) { return r.apply(99); }
class Plus10 : Integer2Integer { Integer2Integer { int apply(int n) { return n + 10; } }
Console.WriteLine(blah(new Plus())); // what does that print?

maybe even a type alias
type Integer2Integer = Int -> Int
blah r = r 99

gregberns

Thanks to @user#0540 and @Globi#0117 on the #beginners discord

Question: Coming from JS/C#/Haskell and trying to understand the & and * a bit better. In this code snippet, the n in the lambda apparently can either be |&n| n%2==0 or |n| *n%2==0. Could some one explain this a bit better? I think its something to do with reference/defreferece, but still not comfortable with those ideas.

let arr: [u16; 5] = [1, 2, 3, 4, 5];
let mut iterator = arr.iter().filter(|&n| n%2==0);

gregberns

NOTE: This is an article by Chris Taylor, originally posted on his blog, but the blog was removed at some point. I resurected it from the WayBack Machine without the authors permission, but post it here for posterity's sake, so others may be able to find it.

Link: https://web.archive.org/web/20140222124650/http://chris-taylor.github.io/blog/2013/02/10/the-algebra-of-algebraic-data-types/

The Algebra of Algebraic Data Types, Part 1

by Chris Taylor

FEB 10TH, 2013

gregberns

import Data.Array (snoc)
import Data.Either (Either(..))

rights :: forall a b. Array (Either a b) -> Array b
rights array =
  let
    f (Left _) accumulator = accumulator
    f (Right value) accumulator = snoc accumulator value
  in
    foldr f [] array

gregberns

import Data.Either (Either(..), either, hush)
import Data.Array (mapMaybe)
import Data.Maybe (Maybe(..))

rights :: forall a b. Array (Either a b) -> Array b
rights array = mapMaybe hush array

-- Also the Lefts implementation
lefts :: forall a b. Array (Either a b) -> Array a
lefts array = mapMaybe (either Just (const Nothing)) array

gregberns

import Data.Array 
import Data.Array.ST (empty, push, freeze)
import Data.Either (Either(..))
import Control.Monad.ST.Internal (ST, foreach)

-- Return Rights from an Array of Either's using the ST monad
rights :: forall a b. Array (Either a b) -> Array b
rights array =
  let
    -- This seems to be required because