mvadu

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

BretFisher

#!/bin/sh

# store the current dir
CUR_DIR=$(pwd)

# Update App Store apps
sudo softwareupdate -i -a

# Update Homebrew (Cask) & packages
brew update

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

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 {

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

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 {

xeno-by

// PROBLEM STATEMENT

// Let's build Proxy[T], an object that can capture calls to methods of an underlying object.
// We want the proxy to be type-safe, i.e. we need to verify that the names of the calls
// and the arguments that are passed to those calls are well-typed wrt the type of the proxee.

object Test extends App {
  trait Foo { /* ... */ }
  val proxy: Proxy[Foo] = ???
  proxy.bar()

idleberg

This script scans your Dropbox (or any given folder) for folders stored in the ignore array and excludes them from syncing. Makes use of the official Dropbox CLI

I'm a beginner at bash, so all improvements are welcome!

#!/bin/bash

set -e

# SETTINGS

IainHull

package org.iainhull.akka


import scala.concurrent.duration._

import akka.actor._
import akka.event.Logging
import akka.pattern.ask
import akka.util.Timeout
import akka.persistence.{PersistentView, AtLeastOnceDelivery, PersistentActor}

ElectricCoffee

import java.io.File

/**
 * A completely OS-Agnostic way of dealing with java.io.File paths
 */
object RichPath {
  sealed class RichBase[+A](left: A) {
    /**
     * Simple enrichment method designed to let you create a java.io.File
     * by simply writing "folderA" / "folderB" / "folderC"