dhavaln

Install HAProxy from Homebre:
`brew install haproxy`

For full reference:
https://serversforhackers.com/load-balancing-with-haproxy

jpallari

Enforcing invariants in Scala datatypes

Scala provides many tools to help us build programs with less runtime errors. Instead of relying on nulls, the recommended practice is to use the Option type. Instead of throwing exceptions, Try and Either types are used for representing potential error scenarios. What’s common with these features is that they’re used for capturing runtime features in the type system, thus lifting the runtime scenario handling to the compilation phase: your program doesn’t compile until you’ve explicitly handled nulls, exceptions, and other runtime features in your code.

In his “Strategic Scala Style” blog post series,

paulp

// These lines go in ~/.sbt/0.13/global.sbt
watchSources ++= (
     (baseDirectory.value * "*.sbt").get
  ++ (baseDirectory.value / "project" * "*.scala").get
  ++ (baseDirectory.value / "project" * "*.sbt").get
)

addCommandAlias("rtu", "; reload ; test:update")
addCommandAlias("rtc", "; reload ; test:compile")
addCommandAlias("ru", "; reload ; update")

mishriky

/**
  * This is not meant to cover ALL possible ways of creating service clients; instead it focuses on the simplest way to
  * do so, while maintaining the capability to customize the clients based on service level agreements/expectations
  *
  * @note Most of the filters can be applied to the HTTP client as well but have been omitted from the sample code to improve
  * readability
  */

trait ClientSamples extends LazyLogging {
  private[this] lazy val config = ConfigFactory.load()

trustin

#!/usr/bin/env bash
set -Eeuo pipefail

log() {
  echo -en '\033[1;32m'
  echo -n "$@"
  echo -e '\033[0m'
}

choice() {

djspiewak

Why not both?

With the recent announcement of cats-effect, a relevant question from the past resurfaces: why does IO, which is otherwise quite Task-like, not define both or race? To be clear, the type signatures of these functions would be as follows:

object IO {
  def both[A, B](ioa: IO[A], iob: IO[B])(implicit EC: ExecutionContext): IO[(A, B)] = ???
  def race[A, B](ioa: IO[A], iob: IO[B])(implicit EC: ExecutionContext): IO[Either[A, B]] = ???
}

djspiewak

Quick Tips for Fast Code on the JVM

I was talking to a coworker recently about general techniques that almost always form the core of any effort to write very fast, down-to-the-metal hot path code on the JVM, and they pointed out that there really isn't a particularly good place to go for this information. It occurred to me that, really, I had more or less picked up all of it by word of mouth and experience, and there just aren't any good reference sources on the topic. So… here's my word of mouth.

This is by no means a comprehensive gist. It's also important to understand that the techniques that I outline in here are not 100% absolute either. Performance on the JVM is an incredibly complicated subject, and while there are rules that almost always hold true, the "almost" remains very salient. Also, for many or even most applications, there will be other techniques that I'm not mentioning which will have a greater impact. JMH, Java Flight Recorder, and a good profiler are your very best friend! Mea

seoh

1. Real World Cats, 엄익훈(카카오)
   • slide
   • repo
2. Shapeless를 이용한 제네릭 프로그래밍: 컴파일러 괴롭히고 단순 작업 줄이기, 박지수(두물머리)
   • slide
   • repo
3. Akka in Practice, 황성현(레이니스트, 뱅크샐러드)
   • slide
4. 배포 후 장애를 대응하는 스마트한 방법. 카나리 릴리즈. 최명규, (비바리퍼블리카, Toss)

dsebban

Undertsanding the Pull type from fs2

From the scaladocs

class Stream[+F[_], +O] extends AnyVal

• A stream producing output of type O
• May evaluate F effects.

danilbykov

import cats.effect.ExitCase._
import cats.effect.Sync
import cats.effect.concurrent.Ref
import cats.syntax.flatMap._
import cats.syntax.functor._

trait Tap[F[_]] {
  def apply[A](effect: F[A]): F[A]
}