bradoaks

#!/bin/bash

# As the "bufferbloat" folks have recently re-discovered and/or more widely
# publicized, congestion avoidance algorithms (such as those found in TCP) do
# a great job of allowing network endpoints to negotiate transfer rates that
# maximize a link's bandwidth usage without unduly penalizing any particular
# stream. This allows bulk transfer streams to use the maximum available
# bandwidth without affecting the latency of non-bulk (e.g. interactive)
# streams.

johan

pledbrook

import org.vertx.groovy.core.Vertx

class BootStrap {

    def init = { servletContext ->
        def vertx = Vertx.newVertx()
        def httpServer = vertx.createHttpServer()
        vertx.createSockJSServer(httpServer).installApp(prefix: '/events') { sock ->
            sock.dataHandler { buff ->
                sock << buff

sumnulu

import org.vertx.groovy.core.Vertx

class BootStrap {

    def init = { servletContext ->
        def vertx = Vertx.newVertx()
        def httpServer = vertx.createHttpServer()
        vertx.createSockJSServer(httpServer).installApp(prefix: '/events') { sock ->
            sock.dataHandler { buff ->
                sock << buff

ericacm

package akka.contrib.pattern

import akka.actor.{Cancellable, ActorLogging, ActorRef, Actor}
import java.util
import akka.serialization.SerializationExtension
import scala.concurrent.ExecutionContext
import scala.concurrent.duration._
import scala.util.{Try, Failure, Success}
import scala.language.existentials
import java.util.UUID

Ryan-ZA

package com.rc;

import java.nio.file.FileSystems;
import java.nio.file.Path;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.vertx.java.core.AsyncResult;
import org.vertx.java.core.Handler;
import org.vertx.java.core.Vertx;

jto

object jto {

  type _1 = Succ[_0]
  type _2 = Succ[_1]
  type _3 = Succ[_2]
  type _4 = Succ[_3]
  type _5 = Succ[_4]

  // Natural numbers (extracted from shapeless)

kushti

package smartcontract.utils

import ch.qos.logback.classic.Level
import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.filter.Filter
import ch.qos.logback.core.spi.FilterReply


/**
 * Code rewritten from Java source

jimmycuadra

YOUR_HOSTED_ZONE_HERE="Route53 zone ID"

case "$1" in
  "clean_challenge")
    altname="$2"
    challenge_token="$3"
    keyauth_hook="$4"

    aws route53 change-resource-record-sets --hosted-zone-id $YOUR_HOSTED_ZONE_HERE --change-batch "{\"Changes\":[{\"Action\":\"DELETE\",\"ResourceRecordSet\":{\"Name\":\"_acme-challenge.${altname}\",\"Type\":\"TXT\",\"TTL\":60,\"ResourceRecords\":[{\"Value\":\"\\\"${keyauth_hook}\\\"\"}]}}]}"
    ;;

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