rklaehn

package akkahttptest

import akka.actor.ActorSystem
import akka.http.Http
import akka.stream.FlowMaterializer
import akka.http.server._
import akka.http.marshalling.PredefinedToResponseMarshallers._
import akka.stream.scaladsl.{HeadSink, Source}

object Proxy extends App {

djspiewak

Git DMZ Flow

I've been asked a few times over the last few months to put together a full write-up of the Git workflow we use at RichRelevance (and at Precog before), since I have referenced it in passing quite a few times in tweets and in person. The workflow is appreciably different from GitFlow and its derivatives, and thus it brings with it a different set of tradeoffs and optimizations. To that end, it would probably be helpful to go over exactly what workflow benefits I find to be beneficial or even necessary.

• Two developers working on independent features must never be blocked by each other
  • No code freeze! Ever! For any reason!
• A developer must be able to base derivative work on another developer's work, without waiting for any third party
• Two developers working on inter-dependent features (or even the same feature) must be able to do so without interference from (or interfering with) any other parties
• Developers must be able to work on multiple features simultaneously, or at lea

kovacshuni

package sample.stream

import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model.headers.RawHeader
import akka.http.scaladsl.server.Route
import akka.stream.ActorFlowMaterializer
import akka.stream.scaladsl.{Sink, Source}

object Proxy extends App {

pchiusano

{-# Language TypeFamilies #-}

module Pcbt where

import Prelude hiding (lookup)
import Data.Set (Set)
import Data.Map (Map)
import qualified Data.Set as Set
import qualified Data.Map.Strict as Map
import Data.Maybe

BretFisher

#!/bin/sh

# store the current dir
CUR_DIR=$(pwd)

# Update App Store apps
sudo softwareupdate -i -a

# Update Homebrew (Cask) & packages
brew update

mvadu

# The full public facing url
#root_url = %(protocol)s://%(domain)s:%(http_port)s/
root_url = http://localhost:80/grafana/

ochrons

import com.amazonaws.HttpMethod
import com.amazonaws.services.s3.AmazonS3Client
import com.amazonaws.services.s3.model._

...
  val s3Client = new AmazonS3Client

  private def getFlow(pathRaw: String, method: HttpMethod) = {
    // clean the path
    val path = pathRaw.dropWhile(_ == '/').trim

jdegoes

Applied Functional Programming with Scala - Notes

Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

jriecken

// Something like this will likely allow propagation of thread-local information

val originalEc: ExecutionContext = ... // the actual execution context
// This will get called every time an implicit EC is necessary, effectively preparing the context
implicit def wrappedEc: ExecutionContext = {
  val ctx = ...// capture thread local context here
  new ExecutionContext {
    override def execute(r: Runnable): Unit = originalEc.execute(new Runnable() {
      override def run(): Unit {
        val oldCtx = ... // get old context

cdelaitre

version: '3'
services:
  # FRONT
  chronograf:
    # Full tag list: https://hub.docker.com/r/library/chronograf/tags/
    image: chronograf
    deploy:
      replicas: 1
      placement:
        constraints: